/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 2.0.4
 * 
 * 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. 
 * ----------------------------------------------------------------------------- */

#define SWIGPYTHON
#define SWIG_DIRECTORS
#define SWIG_PYTHON_THREADS
#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



/* Python.h has to appear first */
#include <Python.h>

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

/* This should only be incremented when either the layout of swig_type_info changes,
   or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "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
#  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 not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  int equiv = 0;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (!equiv && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  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_TypeCompare(const char *nb, const char *tb) {
  int equiv = 0;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (!equiv && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
    if (*ne) ++ne;
  }
  return equiv;
}


/*
  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) {
      register size_t l = 0;
      register size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	register size_t i = (l + r) >> 1; 
	const char *iname = iter->types[i]->name;
	if (iname) {
	  register int compare = strcmp(name, iname);
	  if (compare == 0) {	    
	    return iter->types[i];
	  } else if (compare < 0) {
	    if (i) {
	      r = i - 1;
	    } else {
	      break;
	    }
	  } else if (compare > 0) {
	    l = i + 1;
	  }
	} else {
	  break; /* should never happen */
	}
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

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

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

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

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

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

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

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

#ifdef __cplusplus
}
#endif

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



/* 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 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 < 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()
#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, (char *) 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) {   
  PyDict_SetItemString(d, (char *)name, obj);
  Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, (char *)name, obj);
  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 int
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) {
      register int 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 {
    register 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 {
      register int 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;

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, (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_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
{
  char *str;
#ifdef METH_NOARGS
  PyObject *repr = SwigPyObject_repr(v);
#else
  PyObject *repr = SwigPyObject_repr(v, NULL);
#endif
  if (repr) {
    str = SWIG_Python_str_AsChar(repr); 
    fputs(str, fp);
    SWIG_Python_str_DelForPy3(str);
    Py_DECREF(repr);
    return 0; 
  } else {
    return 1; 
  }
}

SWIGRUNTIME PyObject *
SwigPyObject_str(SwigPyObject *v)
{
  char result[SWIG_BUFFER_SIZE];
  return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
    SWIG_Python_str_FromChar(result) : 0;
}

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;
      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));
      }
      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)) {
    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))
#else
  if (!PyArg_UnpackTuple(args, (char *)"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 *)"aquires 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 *)"aquires 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 >= 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 */
      (printfunc)SwigPyObject_print,        /* 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 */
      (reprfunc)SwigPyObject_str,           /* 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 */
#endif
#ifdef COUNT_ALLOCS
      0,0,0,0                               /* tp_alloc -> 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 */
#endif
#ifdef COUNT_ALLOCS
      0,0,0,0                               /* tp_alloc -> 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;

  if (!obj)
    return SWIG_ERROR;
  if (obj == Py_None) {
    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 (flags & SWIG_POINTER_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);
          }
        }
      }
    }
  }
  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 = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
    PyObject_SetAttr(inst, SWIG_This(), swig_this);
    Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
#else
    PyObject *dict = PyDict_New();
    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;
  PyObject *dict = PyDict_New();
  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,(char*)"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;
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
#ifdef SWIGPYTHON_BUILTIN
      newobj->dict = 0;
#endif
      return (PyObject*) newobj;
    }
    return SWIG_Py_Void();
  }

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

  robj = SwigPyObject_New(ptr, type, own);
  if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    if (inst) {
      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) {
  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_Python_GetModule();
    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 : (char*)"";
}

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;
}

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;

#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;
  }

  res = -1;
  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;
}


#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.swg
 *
 * This file contains support for director classes that proxy
 * method calls from C++ to Python extensions.
 * ----------------------------------------------------------------------------- */

#ifndef SWIG_DIRECTOR_PYTHON_HEADER_
#define SWIG_DIRECTOR_PYTHON_HEADER_

#ifdef __cplusplus

#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 swift
*/
#ifndef SWIG_DIRECTOR_NO_UEH
#ifndef SWIG_DIRECTOR_UEH
#define SWIG_DIRECTOR_UEH
#endif
#endif


/*
  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


/*
  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
#include <map>

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 {
  protected:
    std::string swig_msg;
  public:
    DirectorException(PyObject *error, const char* hdr ="", const char* msg ="") 
      : swig_msg(hdr)
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
      if (strlen(msg)) {
        swig_msg += " ";
        swig_msg += msg;
      }
      if (!PyErr_Occurred()) {
        PyErr_SetString(error, getMessage());
      }
      SWIG_PYTHON_THREAD_END_BLOCK; 
    }

    const char *getMessage() const
    { 
      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.getMessage() << 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 like 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 Swig::DirectorException {
  public:
    DirectorTypeMismatchException(PyObject *error, const char* msg="") 
      : Swig::DirectorException(error, "SWIG director type mismatch", msg)
    {
    }

    DirectorTypeMismatchException(const char* msg="") 
      : Swig::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 Swig::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 Swig::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, optionally taking ownership */
    Director(PyObject* self) : swig_self(self), swig_disown_flag(false) {
      swig_incref();
    }


    /* 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 /* __cplusplus */


#endif

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

#define SWIGTYPE_p_ApplVerID swig_types[0]
#define SWIGTYPE_p_Application swig_types[1]
#define SWIGTYPE_p_BeginString swig_types[2]
#define SWIGTYPE_p_DOMDocumentPtr swig_types[3]
#define SWIGTYPE_p_Data swig_types[4]
#define SWIGTYPE_p_DataDictionary swig_types[5]
#define SWIGTYPE_p_DataDictionaryProvider swig_types[6]
#define SWIGTYPE_p_Dictionaries swig_types[7]
#define SWIGTYPE_p_DoubleField swig_types[8]
#define SWIGTYPE_p_FIX__AMT swig_types[9]
#define SWIGTYPE_p_FIX__Acceptor swig_types[10]
#define SWIGTYPE_p_FIX__Account swig_types[11]
#define SWIGTYPE_p_FIX__AccountType swig_types[12]
#define SWIGTYPE_p_FIX__AccruedInterestAmt swig_types[13]
#define SWIGTYPE_p_FIX__AccruedInterestRate swig_types[14]
#define SWIGTYPE_p_FIX__AcctIDSource swig_types[15]
#define SWIGTYPE_p_FIX__Adjustment swig_types[16]
#define SWIGTYPE_p_FIX__AdjustmentType swig_types[17]
#define SWIGTYPE_p_FIX__AdvId swig_types[18]
#define SWIGTYPE_p_FIX__AdvRefID swig_types[19]
#define SWIGTYPE_p_FIX__AdvSide swig_types[20]
#define SWIGTYPE_p_FIX__AdvTransType swig_types[21]
#define SWIGTYPE_p_FIX__AffectedOrderID swig_types[22]
#define SWIGTYPE_p_FIX__AffectedSecondaryOrderID swig_types[23]
#define SWIGTYPE_p_FIX__AffirmStatus swig_types[24]
#define SWIGTYPE_p_FIX__AggregatedBook swig_types[25]
#define SWIGTYPE_p_FIX__AggressorIndicator swig_types[26]
#define SWIGTYPE_p_FIX__AgreementCurrency swig_types[27]
#define SWIGTYPE_p_FIX__AgreementDate swig_types[28]
#define SWIGTYPE_p_FIX__AgreementDesc swig_types[29]
#define SWIGTYPE_p_FIX__AgreementID swig_types[30]
#define SWIGTYPE_p_FIX__AllocAccount swig_types[31]
#define SWIGTYPE_p_FIX__AllocAccountType swig_types[32]
#define SWIGTYPE_p_FIX__AllocAccruedInterestAmt swig_types[33]
#define SWIGTYPE_p_FIX__AllocAcctIDSource swig_types[34]
#define SWIGTYPE_p_FIX__AllocAvgPx swig_types[35]
#define SWIGTYPE_p_FIX__AllocCancReplaceReason swig_types[36]
#define SWIGTYPE_p_FIX__AllocClearingFeeIndicator swig_types[37]
#define SWIGTYPE_p_FIX__AllocCustomerCapacity swig_types[38]
#define SWIGTYPE_p_FIX__AllocHandlInst swig_types[39]
#define SWIGTYPE_p_FIX__AllocID swig_types[40]
#define SWIGTYPE_p_FIX__AllocInterestAtMaturity swig_types[41]
#define SWIGTYPE_p_FIX__AllocIntermedReqType swig_types[42]
#define SWIGTYPE_p_FIX__AllocLinkID swig_types[43]
#define SWIGTYPE_p_FIX__AllocLinkType swig_types[44]
#define SWIGTYPE_p_FIX__AllocMethod swig_types[45]
#define SWIGTYPE_p_FIX__AllocNetMoney swig_types[46]
#define SWIGTYPE_p_FIX__AllocNoOrdersType swig_types[47]
#define SWIGTYPE_p_FIX__AllocPositionEffect swig_types[48]
#define SWIGTYPE_p_FIX__AllocPrice swig_types[49]
#define SWIGTYPE_p_FIX__AllocQty swig_types[50]
#define SWIGTYPE_p_FIX__AllocRejCode swig_types[51]
#define SWIGTYPE_p_FIX__AllocReportID swig_types[52]
#define SWIGTYPE_p_FIX__AllocReportRefID swig_types[53]
#define SWIGTYPE_p_FIX__AllocReportType swig_types[54]
#define SWIGTYPE_p_FIX__AllocSettlCurrAmt swig_types[55]
#define SWIGTYPE_p_FIX__AllocSettlCurrency swig_types[56]
#define SWIGTYPE_p_FIX__AllocSettlInstType swig_types[57]
#define SWIGTYPE_p_FIX__AllocShares swig_types[58]
#define SWIGTYPE_p_FIX__AllocStatus swig_types[59]
#define SWIGTYPE_p_FIX__AllocText swig_types[60]
#define SWIGTYPE_p_FIX__AllocTransType swig_types[61]
#define SWIGTYPE_p_FIX__AllocType swig_types[62]
#define SWIGTYPE_p_FIX__AllowableOneSidednessCurr swig_types[63]
#define SWIGTYPE_p_FIX__AllowableOneSidednessPct swig_types[64]
#define SWIGTYPE_p_FIX__AllowableOneSidednessValue swig_types[65]
#define SWIGTYPE_p_FIX__AltMDSourceID swig_types[66]
#define SWIGTYPE_p_FIX__ApplBegSeqNum swig_types[67]
#define SWIGTYPE_p_FIX__ApplEndSeqNum swig_types[68]
#define SWIGTYPE_p_FIX__ApplExtID swig_types[69]
#define SWIGTYPE_p_FIX__ApplID swig_types[70]
#define SWIGTYPE_p_FIX__ApplLastSeqNum swig_types[71]
#define SWIGTYPE_p_FIX__ApplNewSeqNum swig_types[72]
#define SWIGTYPE_p_FIX__ApplQueueAction swig_types[73]
#define SWIGTYPE_p_FIX__ApplQueueDepth swig_types[74]
#define SWIGTYPE_p_FIX__ApplQueueMax swig_types[75]
#define SWIGTYPE_p_FIX__ApplQueueResolution swig_types[76]
#define SWIGTYPE_p_FIX__ApplReportID swig_types[77]
#define SWIGTYPE_p_FIX__ApplReportType swig_types[78]
#define SWIGTYPE_p_FIX__ApplReqID swig_types[79]
#define SWIGTYPE_p_FIX__ApplReqType swig_types[80]
#define SWIGTYPE_p_FIX__ApplResendFlag swig_types[81]
#define SWIGTYPE_p_FIX__ApplResponseError swig_types[82]
#define SWIGTYPE_p_FIX__ApplResponseID swig_types[83]
#define SWIGTYPE_p_FIX__ApplResponseType swig_types[84]
#define SWIGTYPE_p_FIX__ApplSeqNum swig_types[85]
#define SWIGTYPE_p_FIX__ApplTotalMessageCount swig_types[86]
#define SWIGTYPE_p_FIX__ApplVerID swig_types[87]
#define SWIGTYPE_p_FIX__Application swig_types[88]
#define SWIGTYPE_p_FIX__AsOfIndicator swig_types[89]
#define SWIGTYPE_p_FIX__AsgnRptID swig_types[90]
#define SWIGTYPE_p_FIX__AssignmentMethod swig_types[91]
#define SWIGTYPE_p_FIX__AssignmentUnit swig_types[92]
#define SWIGTYPE_p_FIX__AttachmentPoint swig_types[93]
#define SWIGTYPE_p_FIX__AutoAcceptIndicator swig_types[94]
#define SWIGTYPE_p_FIX__AvgParPx swig_types[95]
#define SWIGTYPE_p_FIX__AvgPrxPrecision swig_types[96]
#define SWIGTYPE_p_FIX__AvgPx swig_types[97]
#define SWIGTYPE_p_FIX__AvgPxIndicator swig_types[98]
#define SWIGTYPE_p_FIX__AvgPxPrecision swig_types[99]
#define SWIGTYPE_p_FIX__BOOLEAN swig_types[100]
#define SWIGTYPE_p_FIX__BasisFeatureDate swig_types[101]
#define SWIGTYPE_p_FIX__BasisFeaturePrice swig_types[102]
#define SWIGTYPE_p_FIX__BasisPxType swig_types[103]
#define SWIGTYPE_p_FIX__BeginSeqNo swig_types[104]
#define SWIGTYPE_p_FIX__BeginString swig_types[105]
#define SWIGTYPE_p_FIX__Benchmark swig_types[106]
#define SWIGTYPE_p_FIX__BenchmarkCurveCurrency swig_types[107]
#define SWIGTYPE_p_FIX__BenchmarkCurveName swig_types[108]
#define SWIGTYPE_p_FIX__BenchmarkCurvePoint swig_types[109]
#define SWIGTYPE_p_FIX__BenchmarkPrice swig_types[110]
#define SWIGTYPE_p_FIX__BenchmarkPriceType swig_types[111]
#define SWIGTYPE_p_FIX__BenchmarkSecurityID swig_types[112]
#define SWIGTYPE_p_FIX__BenchmarkSecurityIDSource swig_types[113]
#define SWIGTYPE_p_FIX__BidDescriptor swig_types[114]
#define SWIGTYPE_p_FIX__BidDescriptorType swig_types[115]
#define SWIGTYPE_p_FIX__BidForwardPoints swig_types[116]
#define SWIGTYPE_p_FIX__BidForwardPoints2 swig_types[117]
#define SWIGTYPE_p_FIX__BidID swig_types[118]
#define SWIGTYPE_p_FIX__BidPx swig_types[119]
#define SWIGTYPE_p_FIX__BidRequestTransType swig_types[120]
#define SWIGTYPE_p_FIX__BidSize swig_types[121]
#define SWIGTYPE_p_FIX__BidSpotRate swig_types[122]
#define SWIGTYPE_p_FIX__BidSwapPoints swig_types[123]
#define SWIGTYPE_p_FIX__BidTradeType swig_types[124]
#define SWIGTYPE_p_FIX__BidType swig_types[125]
#define SWIGTYPE_p_FIX__BidYield swig_types[126]
#define SWIGTYPE_p_FIX__BodyLength swig_types[127]
#define SWIGTYPE_p_FIX__BookingRefID swig_types[128]
#define SWIGTYPE_p_FIX__BookingType swig_types[129]
#define SWIGTYPE_p_FIX__BookingUnit swig_types[130]
#define SWIGTYPE_p_FIX__BoolField swig_types[131]
#define SWIGTYPE_p_FIX__BrokerOfCredit swig_types[132]
#define SWIGTYPE_p_FIX__BusinessRejectReason swig_types[133]
#define SWIGTYPE_p_FIX__BusinessRejectRefID swig_types[134]
#define SWIGTYPE_p_FIX__BuyVolume swig_types[135]
#define SWIGTYPE_p_FIX__CFICode swig_types[136]
#define SWIGTYPE_p_FIX__CHAR swig_types[137]
#define SWIGTYPE_p_FIX__COUNTRY swig_types[138]
#define SWIGTYPE_p_FIX__CPProgram swig_types[139]
#define SWIGTYPE_p_FIX__CPRegType swig_types[140]
#define SWIGTYPE_p_FIX__CURRENCY swig_types[141]
#define SWIGTYPE_p_FIX__CalculatedCcyLastQty swig_types[142]
#define SWIGTYPE_p_FIX__CancellationRights swig_types[143]
#define SWIGTYPE_p_FIX__CapPrice swig_types[144]
#define SWIGTYPE_p_FIX__CardExpDate swig_types[145]
#define SWIGTYPE_p_FIX__CardHolderName swig_types[146]
#define SWIGTYPE_p_FIX__CardIssNo swig_types[147]
#define SWIGTYPE_p_FIX__CardIssNum swig_types[148]
#define SWIGTYPE_p_FIX__CardNumber swig_types[149]
#define SWIGTYPE_p_FIX__CardStartDate swig_types[150]
#define SWIGTYPE_p_FIX__CashDistribAgentAcctName swig_types[151]
#define SWIGTYPE_p_FIX__CashDistribAgentAcctNumber swig_types[152]
#define SWIGTYPE_p_FIX__CashDistribAgentCode swig_types[153]
#define SWIGTYPE_p_FIX__CashDistribAgentName swig_types[154]
#define SWIGTYPE_p_FIX__CashDistribCurr swig_types[155]
#define SWIGTYPE_p_FIX__CashDistribPayRef swig_types[156]
#define SWIGTYPE_p_FIX__CashMargin swig_types[157]
#define SWIGTYPE_p_FIX__CashOrderQty swig_types[158]
#define SWIGTYPE_p_FIX__CashOutstanding swig_types[159]
#define SWIGTYPE_p_FIX__CashSettlAgentAcctName swig_types[160]
#define SWIGTYPE_p_FIX__CashSettlAgentAcctNum swig_types[161]
#define SWIGTYPE_p_FIX__CashSettlAgentCode swig_types[162]
#define SWIGTYPE_p_FIX__CashSettlAgentContactName swig_types[163]
#define SWIGTYPE_p_FIX__CashSettlAgentContactPhone swig_types[164]
#define SWIGTYPE_p_FIX__CashSettlAgentName swig_types[165]
#define SWIGTYPE_p_FIX__CcyAmt swig_types[166]
#define SWIGTYPE_p_FIX__CharField swig_types[167]
#define SWIGTYPE_p_FIX__CheckSum swig_types[168]
#define SWIGTYPE_p_FIX__CheckSumField swig_types[169]
#define SWIGTYPE_p_FIX__ClOrdID swig_types[170]
#define SWIGTYPE_p_FIX__ClOrdLinkID swig_types[171]
#define SWIGTYPE_p_FIX__ClearingAccount swig_types[172]
#define SWIGTYPE_p_FIX__ClearingBusinessDate swig_types[173]
#define SWIGTYPE_p_FIX__ClearingFeeIndicator swig_types[174]
#define SWIGTYPE_p_FIX__ClearingFirm swig_types[175]
#define SWIGTYPE_p_FIX__ClearingInstruction swig_types[176]
#define SWIGTYPE_p_FIX__ClientBidID swig_types[177]
#define SWIGTYPE_p_FIX__ClientID swig_types[178]
#define SWIGTYPE_p_FIX__CollAction swig_types[179]
#define SWIGTYPE_p_FIX__CollApplType swig_types[180]
#define SWIGTYPE_p_FIX__CollAsgnID swig_types[181]
#define SWIGTYPE_p_FIX__CollAsgnReason swig_types[182]
#define SWIGTYPE_p_FIX__CollAsgnRefID swig_types[183]
#define SWIGTYPE_p_FIX__CollAsgnRejectReason swig_types[184]
#define SWIGTYPE_p_FIX__CollAsgnRespType swig_types[185]
#define SWIGTYPE_p_FIX__CollAsgnTransType swig_types[186]
#define SWIGTYPE_p_FIX__CollInquiryID swig_types[187]
#define SWIGTYPE_p_FIX__CollInquiryQualifier swig_types[188]
#define SWIGTYPE_p_FIX__CollInquiryResult swig_types[189]
#define SWIGTYPE_p_FIX__CollInquiryStatus swig_types[190]
#define SWIGTYPE_p_FIX__CollReqID swig_types[191]
#define SWIGTYPE_p_FIX__CollRespID swig_types[192]
#define SWIGTYPE_p_FIX__CollRptID swig_types[193]
#define SWIGTYPE_p_FIX__CollStatus swig_types[194]
#define SWIGTYPE_p_FIX__CommCurrency swig_types[195]
#define SWIGTYPE_p_FIX__CommType swig_types[196]
#define SWIGTYPE_p_FIX__Commission swig_types[197]
#define SWIGTYPE_p_FIX__ComplexEventCondition swig_types[198]
#define SWIGTYPE_p_FIX__ComplexEventEndDate swig_types[199]
#define SWIGTYPE_p_FIX__ComplexEventEndTime swig_types[200]
#define SWIGTYPE_p_FIX__ComplexEventPrice swig_types[201]
#define SWIGTYPE_p_FIX__ComplexEventPriceBoundaryMethod swig_types[202]
#define SWIGTYPE_p_FIX__ComplexEventPriceBoundaryPrecision swig_types[203]
#define SWIGTYPE_p_FIX__ComplexEventPriceTimeType swig_types[204]
#define SWIGTYPE_p_FIX__ComplexEventStartDate swig_types[205]
#define SWIGTYPE_p_FIX__ComplexEventStartTime swig_types[206]
#define SWIGTYPE_p_FIX__ComplexEventType swig_types[207]
#define SWIGTYPE_p_FIX__ComplexOptPayoutAmount swig_types[208]
#define SWIGTYPE_p_FIX__ComplianceID swig_types[209]
#define SWIGTYPE_p_FIX__Concession swig_types[210]
#define SWIGTYPE_p_FIX__ConfigError swig_types[211]
#define SWIGTYPE_p_FIX__ConfirmID swig_types[212]
#define SWIGTYPE_p_FIX__ConfirmRefID swig_types[213]
#define SWIGTYPE_p_FIX__ConfirmRejReason swig_types[214]
#define SWIGTYPE_p_FIX__ConfirmReqID swig_types[215]
#define SWIGTYPE_p_FIX__ConfirmStatus swig_types[216]
#define SWIGTYPE_p_FIX__ConfirmTransType swig_types[217]
#define SWIGTYPE_p_FIX__ConfirmType swig_types[218]
#define SWIGTYPE_p_FIX__ContAmtCurr swig_types[219]
#define SWIGTYPE_p_FIX__ContAmtType swig_types[220]
#define SWIGTYPE_p_FIX__ContAmtValue swig_types[221]
#define SWIGTYPE_p_FIX__ContIntRptID swig_types[222]
#define SWIGTYPE_p_FIX__ContingencyType swig_types[223]
#define SWIGTYPE_p_FIX__ContraBroker swig_types[224]
#define SWIGTYPE_p_FIX__ContraLegRefID swig_types[225]
#define SWIGTYPE_p_FIX__ContraTradeQty swig_types[226]
#define SWIGTYPE_p_FIX__ContraTradeTime swig_types[227]
#define SWIGTYPE_p_FIX__ContraTrader swig_types[228]
#define SWIGTYPE_p_FIX__ContractMultiplier swig_types[229]
#define SWIGTYPE_p_FIX__ContractMultiplierUnit swig_types[230]
#define SWIGTYPE_p_FIX__ContractSettlMonth swig_types[231]
#define SWIGTYPE_p_FIX__ContraryInstructionIndicator swig_types[232]
#define SWIGTYPE_p_FIX__CopyMsgIndicator swig_types[233]
#define SWIGTYPE_p_FIX__CorporateAction swig_types[234]
#define SWIGTYPE_p_FIX__Country swig_types[235]
#define SWIGTYPE_p_FIX__CountryOfIssue swig_types[236]
#define SWIGTYPE_p_FIX__CouponPaymentDate swig_types[237]
#define SWIGTYPE_p_FIX__CouponRate swig_types[238]
#define SWIGTYPE_p_FIX__CoveredOrUncovered swig_types[239]
#define SWIGTYPE_p_FIX__CreditRating swig_types[240]
#define SWIGTYPE_p_FIX__CrossID swig_types[241]
#define SWIGTYPE_p_FIX__CrossPercent swig_types[242]
#define SWIGTYPE_p_FIX__CrossPrioritization swig_types[243]
#define SWIGTYPE_p_FIX__CrossType swig_types[244]
#define SWIGTYPE_p_FIX__CstmApplVerID swig_types[245]
#define SWIGTYPE_p_FIX__CumQty swig_types[246]
#define SWIGTYPE_p_FIX__Currency swig_types[247]
#define SWIGTYPE_p_FIX__CurrencyRatio swig_types[248]
#define SWIGTYPE_p_FIX__CustDirectedOrder swig_types[249]
#define SWIGTYPE_p_FIX__CustOrderCapacity swig_types[250]
#define SWIGTYPE_p_FIX__CustOrderHandlingInst swig_types[251]
#define SWIGTYPE_p_FIX__CustomerOrFirm swig_types[252]
#define SWIGTYPE_p_FIX__CxlQty swig_types[253]
#define SWIGTYPE_p_FIX__CxlRejReason swig_types[254]
#define SWIGTYPE_p_FIX__CxlRejResponseTo swig_types[255]
#define SWIGTYPE_p_FIX__CxlType swig_types[256]
#define SWIGTYPE_p_FIX__DATA swig_types[257]
#define SWIGTYPE_p_FIX__DAYOFMONTH swig_types[258]
#define SWIGTYPE_p_FIX__DKReason swig_types[259]
#define SWIGTYPE_p_FIX__DataDictionary swig_types[260]
#define SWIGTYPE_p_FIX__DataDictionaryNotFound swig_types[261]
#define SWIGTYPE_p_FIX__DateOfBirth swig_types[262]
#define SWIGTYPE_p_FIX__DatedDate swig_types[263]
#define SWIGTYPE_p_FIX__DayAvgPx swig_types[264]
#define SWIGTYPE_p_FIX__DayBookingInst swig_types[265]
#define SWIGTYPE_p_FIX__DayCumQty swig_types[266]
#define SWIGTYPE_p_FIX__DayOrderQty swig_types[267]
#define SWIGTYPE_p_FIX__DealingCapacity swig_types[268]
#define SWIGTYPE_p_FIX__DefBidSize swig_types[269]
#define SWIGTYPE_p_FIX__DefOfferSize swig_types[270]
#define SWIGTYPE_p_FIX__DefaultApplExtID swig_types[271]
#define SWIGTYPE_p_FIX__DefaultApplVerID swig_types[272]
#define SWIGTYPE_p_FIX__DefaultCstmApplVerID swig_types[273]
#define SWIGTYPE_p_FIX__DefaultVerIndicator swig_types[274]
#define SWIGTYPE_p_FIX__DeleteReason swig_types[275]
#define SWIGTYPE_p_FIX__DeliverToCompID swig_types[276]
#define SWIGTYPE_p_FIX__DeliverToLocationID swig_types[277]
#define SWIGTYPE_p_FIX__DeliverToSubID swig_types[278]
#define SWIGTYPE_p_FIX__DeliveryDate swig_types[279]
#define SWIGTYPE_p_FIX__DeliveryForm swig_types[280]
#define SWIGTYPE_p_FIX__DeliveryType swig_types[281]
#define SWIGTYPE_p_FIX__DerivFlexProductEligibilityIndicator swig_types[282]
#define SWIGTYPE_p_FIX__DerivativeCFICode swig_types[283]
#define SWIGTYPE_p_FIX__DerivativeCapPrice swig_types[284]
#define SWIGTYPE_p_FIX__DerivativeContractMultiplier swig_types[285]
#define SWIGTYPE_p_FIX__DerivativeContractMultiplierUnit swig_types[286]
#define SWIGTYPE_p_FIX__DerivativeContractSettlMonth swig_types[287]
#define SWIGTYPE_p_FIX__DerivativeCountryOfIssue swig_types[288]
#define SWIGTYPE_p_FIX__DerivativeEncodedIssuer swig_types[289]
#define SWIGTYPE_p_FIX__DerivativeEncodedIssuerLen swig_types[290]
#define SWIGTYPE_p_FIX__DerivativeEncodedSecurityDesc swig_types[291]
#define SWIGTYPE_p_FIX__DerivativeEncodedSecurityDescLen swig_types[292]
#define SWIGTYPE_p_FIX__DerivativeEventDate swig_types[293]
#define SWIGTYPE_p_FIX__DerivativeEventPx swig_types[294]
#define SWIGTYPE_p_FIX__DerivativeEventText swig_types[295]
#define SWIGTYPE_p_FIX__DerivativeEventTime swig_types[296]
#define SWIGTYPE_p_FIX__DerivativeEventType swig_types[297]
#define SWIGTYPE_p_FIX__DerivativeExerciseStyle swig_types[298]
#define SWIGTYPE_p_FIX__DerivativeFloorPrice swig_types[299]
#define SWIGTYPE_p_FIX__DerivativeFlowScheduleType swig_types[300]
#define SWIGTYPE_p_FIX__DerivativeFuturesValuationMethod swig_types[301]
#define SWIGTYPE_p_FIX__DerivativeInstrAttribType swig_types[302]
#define SWIGTYPE_p_FIX__DerivativeInstrAttribValue swig_types[303]
#define SWIGTYPE_p_FIX__DerivativeInstrRegistry swig_types[304]
#define SWIGTYPE_p_FIX__DerivativeInstrmtAssignmentMethod swig_types[305]
#define SWIGTYPE_p_FIX__DerivativeInstrumentPartyID swig_types[306]
#define SWIGTYPE_p_FIX__DerivativeInstrumentPartyIDSource swig_types[307]
#define SWIGTYPE_p_FIX__DerivativeInstrumentPartyRole swig_types[308]
#define SWIGTYPE_p_FIX__DerivativeInstrumentPartySubID swig_types[309]
#define SWIGTYPE_p_FIX__DerivativeInstrumentPartySubIDType swig_types[310]
#define SWIGTYPE_p_FIX__DerivativeIssueDate swig_types[311]
#define SWIGTYPE_p_FIX__DerivativeIssuer swig_types[312]
#define SWIGTYPE_p_FIX__DerivativeListMethod swig_types[313]
#define SWIGTYPE_p_FIX__DerivativeLocaleOfIssue swig_types[314]
#define SWIGTYPE_p_FIX__DerivativeMaturityDate swig_types[315]
#define SWIGTYPE_p_FIX__DerivativeMaturityMonthYear swig_types[316]
#define SWIGTYPE_p_FIX__DerivativeMaturityTime swig_types[317]
#define SWIGTYPE_p_FIX__DerivativeMinPriceIncrement swig_types[318]
#define SWIGTYPE_p_FIX__DerivativeMinPriceIncrementAmount swig_types[319]
#define SWIGTYPE_p_FIX__DerivativeNTPositionLimit swig_types[320]
#define SWIGTYPE_p_FIX__DerivativeOptAttribute swig_types[321]
#define SWIGTYPE_p_FIX__DerivativeOptPayAmount swig_types[322]
#define SWIGTYPE_p_FIX__DerivativePositionLimit swig_types[323]
#define SWIGTYPE_p_FIX__DerivativePriceQuoteMethod swig_types[324]
#define SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasure swig_types[325]
#define SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasureQty swig_types[326]
#define SWIGTYPE_p_FIX__DerivativeProduct swig_types[327]
#define SWIGTYPE_p_FIX__DerivativeProductComplex swig_types[328]
#define SWIGTYPE_p_FIX__DerivativePutOrCall swig_types[329]
#define SWIGTYPE_p_FIX__DerivativeSecurityAltID swig_types[330]
#define SWIGTYPE_p_FIX__DerivativeSecurityAltIDSource swig_types[331]
#define SWIGTYPE_p_FIX__DerivativeSecurityDesc swig_types[332]
#define SWIGTYPE_p_FIX__DerivativeSecurityExchange swig_types[333]
#define SWIGTYPE_p_FIX__DerivativeSecurityGroup swig_types[334]
#define SWIGTYPE_p_FIX__DerivativeSecurityID swig_types[335]
#define SWIGTYPE_p_FIX__DerivativeSecurityIDSource swig_types[336]
#define SWIGTYPE_p_FIX__DerivativeSecurityStatus swig_types[337]
#define SWIGTYPE_p_FIX__DerivativeSecuritySubType swig_types[338]
#define SWIGTYPE_p_FIX__DerivativeSecurityType swig_types[339]
#define SWIGTYPE_p_FIX__DerivativeSecurityXML swig_types[340]
#define SWIGTYPE_p_FIX__DerivativeSecurityXMLLen swig_types[341]
#define SWIGTYPE_p_FIX__DerivativeSecurityXMLSchema swig_types[342]
#define SWIGTYPE_p_FIX__DerivativeSettlMethod swig_types[343]
#define SWIGTYPE_p_FIX__DerivativeSettleOnOpenFlag swig_types[344]
#define SWIGTYPE_p_FIX__DerivativeStateOrProvinceOfIssue swig_types[345]
#define SWIGTYPE_p_FIX__DerivativeStrikeCurrency swig_types[346]
#define SWIGTYPE_p_FIX__DerivativeStrikeMultiplier swig_types[347]
#define SWIGTYPE_p_FIX__DerivativeStrikePrice swig_types[348]
#define SWIGTYPE_p_FIX__DerivativeStrikeValue swig_types[349]
#define SWIGTYPE_p_FIX__DerivativeSymbol swig_types[350]
#define SWIGTYPE_p_FIX__DerivativeSymbolSfx swig_types[351]
#define SWIGTYPE_p_FIX__DerivativeTimeUnit swig_types[352]
#define SWIGTYPE_p_FIX__DerivativeUnitOfMeasure swig_types[353]
#define SWIGTYPE_p_FIX__DerivativeUnitOfMeasureQty swig_types[354]
#define SWIGTYPE_p_FIX__DerivativeValuationMethod swig_types[355]
#define SWIGTYPE_p_FIX__Designation swig_types[356]
#define SWIGTYPE_p_FIX__DeskID swig_types[357]
#define SWIGTYPE_p_FIX__DeskOrderHandlingInst swig_types[358]
#define SWIGTYPE_p_FIX__DeskType swig_types[359]
#define SWIGTYPE_p_FIX__DeskTypeSource swig_types[360]
#define SWIGTYPE_p_FIX__DetachmentPoint swig_types[361]
#define SWIGTYPE_p_FIX__Dictionary swig_types[362]
#define SWIGTYPE_p_FIX__Dictionary__Data__const_iterator swig_types[363]
#define SWIGTYPE_p_FIX__DiscretionInst swig_types[364]
#define SWIGTYPE_p_FIX__DiscretionLimitType swig_types[365]
#define SWIGTYPE_p_FIX__DiscretionMoveType swig_types[366]
#define SWIGTYPE_p_FIX__DiscretionOffset swig_types[367]
#define SWIGTYPE_p_FIX__DiscretionOffsetType swig_types[368]
#define SWIGTYPE_p_FIX__DiscretionOffsetValue swig_types[369]
#define SWIGTYPE_p_FIX__DiscretionPrice swig_types[370]
#define SWIGTYPE_p_FIX__DiscretionRoundDirection swig_types[371]
#define SWIGTYPE_p_FIX__DiscretionScope swig_types[372]
#define SWIGTYPE_p_FIX__DisplayHighQty swig_types[373]
#define SWIGTYPE_p_FIX__DisplayLowQty swig_types[374]
#define SWIGTYPE_p_FIX__DisplayMethod swig_types[375]
#define SWIGTYPE_p_FIX__DisplayMinIncr swig_types[376]
#define SWIGTYPE_p_FIX__DisplayQty swig_types[377]
#define SWIGTYPE_p_FIX__DisplayWhen swig_types[378]
#define SWIGTYPE_p_FIX__DistribPaymentMethod swig_types[379]
#define SWIGTYPE_p_FIX__DistribPercentage swig_types[380]
#define SWIGTYPE_p_FIX__DividendYield swig_types[381]
#define SWIGTYPE_p_FIX__DlvyInst swig_types[382]
#define SWIGTYPE_p_FIX__DlvyInstType swig_types[383]
#define SWIGTYPE_p_FIX__DoNotSend swig_types[384]
#define SWIGTYPE_p_FIX__DoubleField swig_types[385]
#define SWIGTYPE_p_FIX__DueToRelated swig_types[386]
#define SWIGTYPE_p_FIX__DuplicateFieldNumber swig_types[387]
#define SWIGTYPE_p_FIX__EFPTrackingError swig_types[388]
#define SWIGTYPE_p_FIX__EXCHANGE swig_types[389]
#define SWIGTYPE_p_FIX__EffectiveTime swig_types[390]
#define SWIGTYPE_p_FIX__EmailThreadID swig_types[391]
#define SWIGTYPE_p_FIX__EmailType swig_types[392]
#define SWIGTYPE_p_FIX__EncodedAllocText swig_types[393]
#define SWIGTYPE_p_FIX__EncodedAllocTextLen swig_types[394]
#define SWIGTYPE_p_FIX__EncodedHeadline swig_types[395]
#define SWIGTYPE_p_FIX__EncodedHeadlineLen swig_types[396]
#define SWIGTYPE_p_FIX__EncodedIssuer swig_types[397]
#define SWIGTYPE_p_FIX__EncodedIssuerLen swig_types[398]
#define SWIGTYPE_p_FIX__EncodedLegIssuer swig_types[399]
#define SWIGTYPE_p_FIX__EncodedLegIssuerLen swig_types[400]
#define SWIGTYPE_p_FIX__EncodedLegSecurityDesc swig_types[401]
#define SWIGTYPE_p_FIX__EncodedLegSecurityDescLen swig_types[402]
#define SWIGTYPE_p_FIX__EncodedListExecInst swig_types[403]
#define SWIGTYPE_p_FIX__EncodedListExecInstLen swig_types[404]
#define SWIGTYPE_p_FIX__EncodedListStatusText swig_types[405]
#define SWIGTYPE_p_FIX__EncodedListStatusTextLen swig_types[406]
#define SWIGTYPE_p_FIX__EncodedMktSegmDesc swig_types[407]
#define SWIGTYPE_p_FIX__EncodedMktSegmDescLen swig_types[408]
#define SWIGTYPE_p_FIX__EncodedSecurityDesc swig_types[409]
#define SWIGTYPE_p_FIX__EncodedSecurityDescLen swig_types[410]
#define SWIGTYPE_p_FIX__EncodedSecurityListDesc swig_types[411]
#define SWIGTYPE_p_FIX__EncodedSecurityListDescLen swig_types[412]
#define SWIGTYPE_p_FIX__EncodedSubject swig_types[413]
#define SWIGTYPE_p_FIX__EncodedSubjectLen swig_types[414]
#define SWIGTYPE_p_FIX__EncodedText swig_types[415]
#define SWIGTYPE_p_FIX__EncodedTextLen swig_types[416]
#define SWIGTYPE_p_FIX__EncodedUnderlyingIssuer swig_types[417]
#define SWIGTYPE_p_FIX__EncodedUnderlyingIssuerLen swig_types[418]
#define SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDesc swig_types[419]
#define SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDescLen swig_types[420]
#define SWIGTYPE_p_FIX__EncryptMethod swig_types[421]
#define SWIGTYPE_p_FIX__EncryptedNewPassword swig_types[422]
#define SWIGTYPE_p_FIX__EncryptedNewPasswordLen swig_types[423]
#define SWIGTYPE_p_FIX__EncryptedPassword swig_types[424]
#define SWIGTYPE_p_FIX__EncryptedPasswordLen swig_types[425]
#define SWIGTYPE_p_FIX__EncryptedPasswordMethod swig_types[426]
#define SWIGTYPE_p_FIX__EndAccruedInterestAmt swig_types[427]
#define SWIGTYPE_p_FIX__EndCash swig_types[428]
#define SWIGTYPE_p_FIX__EndDate swig_types[429]
#define SWIGTYPE_p_FIX__EndMaturityMonthYear swig_types[430]
#define SWIGTYPE_p_FIX__EndSeqNo swig_types[431]
#define SWIGTYPE_p_FIX__EndStrikePxRange swig_types[432]
#define SWIGTYPE_p_FIX__EndTickPriceRange swig_types[433]
#define SWIGTYPE_p_FIX__EventDate swig_types[434]
#define SWIGTYPE_p_FIX__EventPx swig_types[435]
#define SWIGTYPE_p_FIX__EventText swig_types[436]
#define SWIGTYPE_p_FIX__EventTime swig_types[437]
#define SWIGTYPE_p_FIX__EventType swig_types[438]
#define SWIGTYPE_p_FIX__ExDate swig_types[439]
#define SWIGTYPE_p_FIX__ExDestination swig_types[440]
#define SWIGTYPE_p_FIX__ExDestinationIDSource swig_types[441]
#define SWIGTYPE_p_FIX__Exception swig_types[442]
#define SWIGTYPE_p_FIX__ExchangeForPhysical swig_types[443]
#define SWIGTYPE_p_FIX__ExchangeRule swig_types[444]
#define SWIGTYPE_p_FIX__ExchangeSpecialInstructions swig_types[445]
#define SWIGTYPE_p_FIX__ExecAckStatus swig_types[446]
#define SWIGTYPE_p_FIX__ExecBroker swig_types[447]
#define SWIGTYPE_p_FIX__ExecID swig_types[448]
#define SWIGTYPE_p_FIX__ExecInst swig_types[449]
#define SWIGTYPE_p_FIX__ExecInstValue swig_types[450]
#define SWIGTYPE_p_FIX__ExecPriceAdjustment swig_types[451]
#define SWIGTYPE_p_FIX__ExecPriceType swig_types[452]
#define SWIGTYPE_p_FIX__ExecRefID swig_types[453]
#define SWIGTYPE_p_FIX__ExecRestatementReason swig_types[454]
#define SWIGTYPE_p_FIX__ExecTransType swig_types[455]
#define SWIGTYPE_p_FIX__ExecType swig_types[456]
#define SWIGTYPE_p_FIX__ExecValuationPoint swig_types[457]
#define SWIGTYPE_p_FIX__ExerciseMethod swig_types[458]
#define SWIGTYPE_p_FIX__ExerciseStyle swig_types[459]
#define SWIGTYPE_p_FIX__ExpQty swig_types[460]
#define SWIGTYPE_p_FIX__ExpType swig_types[461]
#define SWIGTYPE_p_FIX__ExpirationCycle swig_types[462]
#define SWIGTYPE_p_FIX__ExpirationQtyType swig_types[463]
#define SWIGTYPE_p_FIX__ExpireDate swig_types[464]
#define SWIGTYPE_p_FIX__ExpireTime swig_types[465]
#define SWIGTYPE_p_FIX__FLOAT swig_types[466]
#define SWIGTYPE_p_FIX__Factor swig_types[467]
#define SWIGTYPE_p_FIX__FairValue swig_types[468]
#define SWIGTYPE_p_FIX__FeeMultiplier swig_types[469]
#define SWIGTYPE_p_FIX__FieldBase swig_types[470]
#define SWIGTYPE_p_FIX__FieldConvertError swig_types[471]
#define SWIGTYPE_p_FIX__FieldMap swig_types[472]
#define SWIGTYPE_p_FIX__FieldMap__Fields__const_iterator swig_types[473]
#define SWIGTYPE_p_FIX__FieldMap__Groups__const_iterator swig_types[474]
#define SWIGTYPE_p_FIX__FieldNotFound swig_types[475]
#define SWIGTYPE_p_FIX__FileLog swig_types[476]
#define SWIGTYPE_p_FIX__FileLogFactory swig_types[477]
#define SWIGTYPE_p_FIX__FileStore swig_types[478]
#define SWIGTYPE_p_FIX__FileStoreFactory swig_types[479]
#define SWIGTYPE_p_FIX__FillExecID swig_types[480]
#define SWIGTYPE_p_FIX__FillLiquidityInd swig_types[481]
#define SWIGTYPE_p_FIX__FillPx swig_types[482]
#define SWIGTYPE_p_FIX__FillQty swig_types[483]
#define SWIGTYPE_p_FIX__FinancialStatus swig_types[484]
#define SWIGTYPE_p_FIX__FirmTradeID swig_types[485]
#define SWIGTYPE_p_FIX__FirstPx swig_types[486]
#define SWIGTYPE_p_FIX__FlexProductEligibilityIndicator swig_types[487]
#define SWIGTYPE_p_FIX__FlexibleIndicator swig_types[488]
#define SWIGTYPE_p_FIX__FloorPrice swig_types[489]
#define SWIGTYPE_p_FIX__FlowScheduleType swig_types[490]
#define SWIGTYPE_p_FIX__ForexReq swig_types[491]
#define SWIGTYPE_p_FIX__FundRenewWaiv swig_types[492]
#define SWIGTYPE_p_FIX__FutSettDate swig_types[493]
#define SWIGTYPE_p_FIX__FutSettDate2 swig_types[494]
#define SWIGTYPE_p_FIX__FuturesValuationMethod swig_types[495]
#define SWIGTYPE_p_FIX__GTBookingInst swig_types[496]
#define SWIGTYPE_p_FIX__GapFillFlag swig_types[497]
#define SWIGTYPE_p_FIX__GrossTradeAmt swig_types[498]
#define SWIGTYPE_p_FIX__Group swig_types[499]
#define SWIGTYPE_p_FIX__HaltReasonChar swig_types[500]
#define SWIGTYPE_p_FIX__HaltReasonInt swig_types[501]
#define SWIGTYPE_p_FIX__HandlInst swig_types[502]
#define SWIGTYPE_p_FIX__Header swig_types[503]
#define SWIGTYPE_p_FIX__Headline swig_types[504]
#define SWIGTYPE_p_FIX__HeartBtInt swig_types[505]
#define SWIGTYPE_p_FIX__HighLimitPrice swig_types[506]
#define SWIGTYPE_p_FIX__HighPx swig_types[507]
#define SWIGTYPE_p_FIX__HopCompID swig_types[508]
#define SWIGTYPE_p_FIX__HopRefID swig_types[509]
#define SWIGTYPE_p_FIX__HopSendingTime swig_types[510]
#define SWIGTYPE_p_FIX__HostCrossID swig_types[511]
#define SWIGTYPE_p_FIX__IDSource swig_types[512]
#define SWIGTYPE_p_FIX__INT swig_types[513]
#define SWIGTYPE_p_FIX__IOException swig_types[514]
#define SWIGTYPE_p_FIX__IOIID swig_types[515]
#define SWIGTYPE_p_FIX__IOINaturalFlag swig_types[516]
#define SWIGTYPE_p_FIX__IOIOthSvc swig_types[517]
#define SWIGTYPE_p_FIX__IOIQltyInd swig_types[518]
#define SWIGTYPE_p_FIX__IOIQty swig_types[519]
#define SWIGTYPE_p_FIX__IOIQualifier swig_types[520]
#define SWIGTYPE_p_FIX__IOIRefID swig_types[521]
#define SWIGTYPE_p_FIX__IOIShares swig_types[522]
#define SWIGTYPE_p_FIX__IOITransType swig_types[523]
#define SWIGTYPE_p_FIX__IOIid swig_types[524]
#define SWIGTYPE_p_FIX__ImpliedMarketIndicator swig_types[525]
#define SWIGTYPE_p_FIX__InViewOfCommon swig_types[526]
#define SWIGTYPE_p_FIX__IncTaxInd swig_types[527]
#define SWIGTYPE_p_FIX__IncorrectDataFormat swig_types[528]
#define SWIGTYPE_p_FIX__IncorrectMessageStructure swig_types[529]
#define SWIGTYPE_p_FIX__IncorrectTagValue swig_types[530]
#define SWIGTYPE_p_FIX__IndividualAllocID swig_types[531]
#define SWIGTYPE_p_FIX__IndividualAllocRejCode swig_types[532]
#define SWIGTYPE_p_FIX__IndividualAllocType swig_types[533]
#define SWIGTYPE_p_FIX__Initiator swig_types[534]
#define SWIGTYPE_p_FIX__InputSource swig_types[535]
#define SWIGTYPE_p_FIX__InstrAttribType swig_types[536]
#define SWIGTYPE_p_FIX__InstrAttribValue swig_types[537]
#define SWIGTYPE_p_FIX__InstrRegistry swig_types[538]
#define SWIGTYPE_p_FIX__InstrmtAssignmentMethod swig_types[539]
#define SWIGTYPE_p_FIX__InstrumentPartyID swig_types[540]
#define SWIGTYPE_p_FIX__InstrumentPartyIDSource swig_types[541]
#define SWIGTYPE_p_FIX__InstrumentPartyRole swig_types[542]
#define SWIGTYPE_p_FIX__InstrumentPartySubID swig_types[543]
#define SWIGTYPE_p_FIX__InstrumentPartySubIDType swig_types[544]
#define SWIGTYPE_p_FIX__IntField swig_types[545]
#define SWIGTYPE_p_FIX__InterestAccrualDate swig_types[546]
#define SWIGTYPE_p_FIX__InterestAtMaturity swig_types[547]
#define SWIGTYPE_p_FIX__InvalidMessage swig_types[548]
#define SWIGTYPE_p_FIX__InvalidMessageType swig_types[549]
#define SWIGTYPE_p_FIX__InvalidTagNumber swig_types[550]
#define SWIGTYPE_p_FIX__InvestorCountryOfResidence swig_types[551]
#define SWIGTYPE_p_FIX__IssueDate swig_types[552]
#define SWIGTYPE_p_FIX__Issuer swig_types[553]
#define SWIGTYPE_p_FIX__LANGUAGE swig_types[554]
#define SWIGTYPE_p_FIX__LENGTH swig_types[555]
#define SWIGTYPE_p_FIX__LOCALMKTDATE swig_types[556]
#define SWIGTYPE_p_FIX__LanguageCode swig_types[557]
#define SWIGTYPE_p_FIX__LastCapacity swig_types[558]
#define SWIGTYPE_p_FIX__LastForwardPoints swig_types[559]
#define SWIGTYPE_p_FIX__LastForwardPoints2 swig_types[560]
#define SWIGTYPE_p_FIX__LastFragment swig_types[561]
#define SWIGTYPE_p_FIX__LastLiquidityInd swig_types[562]
#define SWIGTYPE_p_FIX__LastMkt swig_types[563]
#define SWIGTYPE_p_FIX__LastMsgSeqNumProcessed swig_types[564]
#define SWIGTYPE_p_FIX__LastNetworkResponseID swig_types[565]
#define SWIGTYPE_p_FIX__LastParPx swig_types[566]
#define SWIGTYPE_p_FIX__LastPx swig_types[567]
#define SWIGTYPE_p_FIX__LastQty swig_types[568]
#define SWIGTYPE_p_FIX__LastRptRequested swig_types[569]
#define SWIGTYPE_p_FIX__LastShares swig_types[570]
#define SWIGTYPE_p_FIX__LastSpotRate swig_types[571]
#define SWIGTYPE_p_FIX__LastSwapPoints swig_types[572]
#define SWIGTYPE_p_FIX__LastUpdateTime swig_types[573]
#define SWIGTYPE_p_FIX__LateIndicator swig_types[574]
#define SWIGTYPE_p_FIX__LeavesQty swig_types[575]
#define SWIGTYPE_p_FIX__LegAllocAccount swig_types[576]
#define SWIGTYPE_p_FIX__LegAllocAcctIDSource swig_types[577]
#define SWIGTYPE_p_FIX__LegAllocID swig_types[578]
#define SWIGTYPE_p_FIX__LegAllocQty swig_types[579]
#define SWIGTYPE_p_FIX__LegAllocSettlCurrency swig_types[580]
#define SWIGTYPE_p_FIX__LegBenchmarkCurveCurrency swig_types[581]
#define SWIGTYPE_p_FIX__LegBenchmarkCurveName swig_types[582]
#define SWIGTYPE_p_FIX__LegBenchmarkCurvePoint swig_types[583]
#define SWIGTYPE_p_FIX__LegBenchmarkPrice swig_types[584]
#define SWIGTYPE_p_FIX__LegBenchmarkPriceType swig_types[585]
#define SWIGTYPE_p_FIX__LegBidForwardPoints swig_types[586]
#define SWIGTYPE_p_FIX__LegBidPx swig_types[587]
#define SWIGTYPE_p_FIX__LegCFICode swig_types[588]
#define SWIGTYPE_p_FIX__LegCalculatedCcyLastQty swig_types[589]
#define SWIGTYPE_p_FIX__LegContractMultiplier swig_types[590]
#define SWIGTYPE_p_FIX__LegContractMultiplierUnit swig_types[591]
#define SWIGTYPE_p_FIX__LegContractSettlMonth swig_types[592]
#define SWIGTYPE_p_FIX__LegCountryOfIssue swig_types[593]
#define SWIGTYPE_p_FIX__LegCouponPaymentDate swig_types[594]
#define SWIGTYPE_p_FIX__LegCouponRate swig_types[595]
#define SWIGTYPE_p_FIX__LegCoveredOrUncovered swig_types[596]
#define SWIGTYPE_p_FIX__LegCreditRating swig_types[597]
#define SWIGTYPE_p_FIX__LegCurrency swig_types[598]
#define SWIGTYPE_p_FIX__LegCurrencyRatio swig_types[599]
#define SWIGTYPE_p_FIX__LegDatedDate swig_types[600]
#define SWIGTYPE_p_FIX__LegDividendYield swig_types[601]
#define SWIGTYPE_p_FIX__LegExecInst swig_types[602]
#define SWIGTYPE_p_FIX__LegExerciseStyle swig_types[603]
#define SWIGTYPE_p_FIX__LegFactor swig_types[604]
#define SWIGTYPE_p_FIX__LegFlowScheduleType swig_types[605]
#define SWIGTYPE_p_FIX__LegFutSettDate swig_types[606]
#define SWIGTYPE_p_FIX__LegGrossTradeAmt swig_types[607]
#define SWIGTYPE_p_FIX__LegIOIQty swig_types[608]
#define SWIGTYPE_p_FIX__LegIndividualAllocID swig_types[609]
#define SWIGTYPE_p_FIX__LegInstrRegistry swig_types[610]
#define SWIGTYPE_p_FIX__LegInterestAccrualDate swig_types[611]
#define SWIGTYPE_p_FIX__LegIssueDate swig_types[612]
#define SWIGTYPE_p_FIX__LegIssuer swig_types[613]
#define SWIGTYPE_p_FIX__LegLastForwardPoints swig_types[614]
#define SWIGTYPE_p_FIX__LegLastPx swig_types[615]
#define SWIGTYPE_p_FIX__LegLastQty swig_types[616]
#define SWIGTYPE_p_FIX__LegLocaleOfIssue swig_types[617]
#define SWIGTYPE_p_FIX__LegMaturityDate swig_types[618]
#define SWIGTYPE_p_FIX__LegMaturityMonthYear swig_types[619]
#define SWIGTYPE_p_FIX__LegMaturityTime swig_types[620]
#define SWIGTYPE_p_FIX__LegNumber swig_types[621]
#define SWIGTYPE_p_FIX__LegOfferForwardPoints swig_types[622]
#define SWIGTYPE_p_FIX__LegOfferPx swig_types[623]
#define SWIGTYPE_p_FIX__LegOptAttribute swig_types[624]
#define SWIGTYPE_p_FIX__LegOptionRatio swig_types[625]
#define SWIGTYPE_p_FIX__LegOrderQty swig_types[626]
#define SWIGTYPE_p_FIX__LegPool swig_types[627]
#define SWIGTYPE_p_FIX__LegPositionEffect swig_types[628]
#define SWIGTYPE_p_FIX__LegPrice swig_types[629]
#define SWIGTYPE_p_FIX__LegPriceType swig_types[630]
#define SWIGTYPE_p_FIX__LegPriceUnitOfMeasure swig_types[631]
#define SWIGTYPE_p_FIX__LegPriceUnitOfMeasureQty swig_types[632]
#define SWIGTYPE_p_FIX__LegProduct swig_types[633]
#define SWIGTYPE_p_FIX__LegPutOrCall swig_types[634]
#define SWIGTYPE_p_FIX__LegQty swig_types[635]
#define SWIGTYPE_p_FIX__LegRatioQty swig_types[636]
#define SWIGTYPE_p_FIX__LegRedemptionDate swig_types[637]
#define SWIGTYPE_p_FIX__LegRefID swig_types[638]
#define SWIGTYPE_p_FIX__LegRepoCollateralSecurityType swig_types[639]
#define SWIGTYPE_p_FIX__LegReportID swig_types[640]
#define SWIGTYPE_p_FIX__LegRepurchaseRate swig_types[641]
#define SWIGTYPE_p_FIX__LegRepurchaseTerm swig_types[642]
#define SWIGTYPE_p_FIX__LegSecurityAltID swig_types[643]
#define SWIGTYPE_p_FIX__LegSecurityAltIDSource swig_types[644]
#define SWIGTYPE_p_FIX__LegSecurityDesc swig_types[645]
#define SWIGTYPE_p_FIX__LegSecurityExchange swig_types[646]
#define SWIGTYPE_p_FIX__LegSecurityID swig_types[647]
#define SWIGTYPE_p_FIX__LegSecurityIDSource swig_types[648]
#define SWIGTYPE_p_FIX__LegSecuritySubType swig_types[649]
#define SWIGTYPE_p_FIX__LegSecurityType swig_types[650]
#define SWIGTYPE_p_FIX__LegSettlCurrency swig_types[651]
#define SWIGTYPE_p_FIX__LegSettlDate swig_types[652]
#define SWIGTYPE_p_FIX__LegSettlType swig_types[653]
#define SWIGTYPE_p_FIX__LegSettlmntTyp swig_types[654]
#define SWIGTYPE_p_FIX__LegSide swig_types[655]
#define SWIGTYPE_p_FIX__LegStateOrProvinceOfIssue swig_types[656]
#define SWIGTYPE_p_FIX__LegStipulationType swig_types[657]
#define SWIGTYPE_p_FIX__LegStipulationValue swig_types[658]
#define SWIGTYPE_p_FIX__LegStrikeCurrency swig_types[659]
#define SWIGTYPE_p_FIX__LegStrikePrice swig_types[660]
#define SWIGTYPE_p_FIX__LegSwapType swig_types[661]
#define SWIGTYPE_p_FIX__LegSymbol swig_types[662]
#define SWIGTYPE_p_FIX__LegSymbolSfx swig_types[663]
#define SWIGTYPE_p_FIX__LegTimeUnit swig_types[664]
#define SWIGTYPE_p_FIX__LegUnitOfMeasure swig_types[665]
#define SWIGTYPE_p_FIX__LegUnitOfMeasureQty swig_types[666]
#define SWIGTYPE_p_FIX__LegVolatility swig_types[667]
#define SWIGTYPE_p_FIX__LegalConfirm swig_types[668]
#define SWIGTYPE_p_FIX__LinesOfText swig_types[669]
#define SWIGTYPE_p_FIX__LiquidityIndType swig_types[670]
#define SWIGTYPE_p_FIX__LiquidityNumSecurities swig_types[671]
#define SWIGTYPE_p_FIX__LiquidityPctHigh swig_types[672]
#define SWIGTYPE_p_FIX__LiquidityPctLow swig_types[673]
#define SWIGTYPE_p_FIX__LiquidityValue swig_types[674]
#define SWIGTYPE_p_FIX__ListExecInst swig_types[675]
#define SWIGTYPE_p_FIX__ListExecInstType swig_types[676]
#define SWIGTYPE_p_FIX__ListID swig_types[677]
#define SWIGTYPE_p_FIX__ListMethod swig_types[678]
#define SWIGTYPE_p_FIX__ListName swig_types[679]
#define SWIGTYPE_p_FIX__ListNoOrds swig_types[680]
#define SWIGTYPE_p_FIX__ListOrderStatus swig_types[681]
#define SWIGTYPE_p_FIX__ListRejectReason swig_types[682]
#define SWIGTYPE_p_FIX__ListSeqNo swig_types[683]
#define SWIGTYPE_p_FIX__ListStatusText swig_types[684]
#define SWIGTYPE_p_FIX__ListStatusType swig_types[685]
#define SWIGTYPE_p_FIX__ListUpdateAction swig_types[686]
#define SWIGTYPE_p_FIX__LocaleOfIssue swig_types[687]
#define SWIGTYPE_p_FIX__LocateReqd swig_types[688]
#define SWIGTYPE_p_FIX__LocationID swig_types[689]
#define SWIGTYPE_p_FIX__Log swig_types[690]
#define SWIGTYPE_p_FIX__LogFactory swig_types[691]
#define SWIGTYPE_p_FIX__LongQty swig_types[692]
#define SWIGTYPE_p_FIX__LotType swig_types[693]
#define SWIGTYPE_p_FIX__LowLimitPrice swig_types[694]
#define SWIGTYPE_p_FIX__LowPx swig_types[695]
#define SWIGTYPE_p_FIX__MDBookType swig_types[696]
#define SWIGTYPE_p_FIX__MDEntryBuyer swig_types[697]
#define SWIGTYPE_p_FIX__MDEntryDate swig_types[698]
#define SWIGTYPE_p_FIX__MDEntryForwardPoints swig_types[699]
#define SWIGTYPE_p_FIX__MDEntryID swig_types[700]
#define SWIGTYPE_p_FIX__MDEntryOriginator swig_types[701]
#define SWIGTYPE_p_FIX__MDEntryPositionNo swig_types[702]
#define SWIGTYPE_p_FIX__MDEntryPx swig_types[703]
#define SWIGTYPE_p_FIX__MDEntryRefID swig_types[704]
#define SWIGTYPE_p_FIX__MDEntrySeller swig_types[705]
#define SWIGTYPE_p_FIX__MDEntrySize swig_types[706]
#define SWIGTYPE_p_FIX__MDEntrySpotRate swig_types[707]
#define SWIGTYPE_p_FIX__MDEntryTime swig_types[708]
#define SWIGTYPE_p_FIX__MDEntryType swig_types[709]
#define SWIGTYPE_p_FIX__MDFeedType swig_types[710]
#define SWIGTYPE_p_FIX__MDImplicitDelete swig_types[711]
#define SWIGTYPE_p_FIX__MDMkt swig_types[712]
#define SWIGTYPE_p_FIX__MDOriginType swig_types[713]
#define SWIGTYPE_p_FIX__MDPriceLevel swig_types[714]
#define SWIGTYPE_p_FIX__MDQuoteType swig_types[715]
#define SWIGTYPE_p_FIX__MDReportID swig_types[716]
#define SWIGTYPE_p_FIX__MDReqID swig_types[717]
#define SWIGTYPE_p_FIX__MDReqRejReason swig_types[718]
#define SWIGTYPE_p_FIX__MDSecSize swig_types[719]
#define SWIGTYPE_p_FIX__MDSecSizeType swig_types[720]
#define SWIGTYPE_p_FIX__MDStreamID swig_types[721]
#define SWIGTYPE_p_FIX__MDSubBookType swig_types[722]
#define SWIGTYPE_p_FIX__MDUpdateAction swig_types[723]
#define SWIGTYPE_p_FIX__MDUpdateType swig_types[724]
#define SWIGTYPE_p_FIX__MONTHYEAR swig_types[725]
#define SWIGTYPE_p_FIX__MULTIPLECHARVALUE swig_types[726]
#define SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE swig_types[727]
#define SWIGTYPE_p_FIX__MULTIPLEVALUESTRING swig_types[728]
#define SWIGTYPE_p_FIX__MailingDtls swig_types[729]
#define SWIGTYPE_p_FIX__MailingInst swig_types[730]
#define SWIGTYPE_p_FIX__ManualOrderIndicator swig_types[731]
#define SWIGTYPE_p_FIX__MarginExcess swig_types[732]
#define SWIGTYPE_p_FIX__MarginRatio swig_types[733]
#define SWIGTYPE_p_FIX__MarketDepth swig_types[734]
#define SWIGTYPE_p_FIX__MarketID swig_types[735]
#define SWIGTYPE_p_FIX__MarketReportID swig_types[736]
#define SWIGTYPE_p_FIX__MarketReqID swig_types[737]
#define SWIGTYPE_p_FIX__MarketSegmentDesc swig_types[738]
#define SWIGTYPE_p_FIX__MarketSegmentID swig_types[739]
#define SWIGTYPE_p_FIX__MarketUpdateAction swig_types[740]
#define SWIGTYPE_p_FIX__MassActionRejectReason swig_types[741]
#define SWIGTYPE_p_FIX__MassActionReportID swig_types[742]
#define SWIGTYPE_p_FIX__MassActionResponse swig_types[743]
#define SWIGTYPE_p_FIX__MassActionScope swig_types[744]
#define SWIGTYPE_p_FIX__MassActionType swig_types[745]
#define SWIGTYPE_p_FIX__MassCancelRejectReason swig_types[746]
#define SWIGTYPE_p_FIX__MassCancelRequestType swig_types[747]
#define SWIGTYPE_p_FIX__MassCancelResponse swig_types[748]
#define SWIGTYPE_p_FIX__MassStatusReqID swig_types[749]
#define SWIGTYPE_p_FIX__MassStatusReqType swig_types[750]
#define SWIGTYPE_p_FIX__MatchAlgorithm swig_types[751]
#define SWIGTYPE_p_FIX__MatchIncrement swig_types[752]
#define SWIGTYPE_p_FIX__MatchStatus swig_types[753]
#define SWIGTYPE_p_FIX__MatchType swig_types[754]
#define SWIGTYPE_p_FIX__MaturityDate swig_types[755]
#define SWIGTYPE_p_FIX__MaturityDay swig_types[756]
#define SWIGTYPE_p_FIX__MaturityMonthYear swig_types[757]
#define SWIGTYPE_p_FIX__MaturityMonthYearFormat swig_types[758]
#define SWIGTYPE_p_FIX__MaturityMonthYearIncrement swig_types[759]
#define SWIGTYPE_p_FIX__MaturityMonthYearIncrementUnits swig_types[760]
#define SWIGTYPE_p_FIX__MaturityNetMoney swig_types[761]
#define SWIGTYPE_p_FIX__MaturityRuleID swig_types[762]
#define SWIGTYPE_p_FIX__MaturityTime swig_types[763]
#define SWIGTYPE_p_FIX__MaxFloor swig_types[764]
#define SWIGTYPE_p_FIX__MaxMessageSize swig_types[765]
#define SWIGTYPE_p_FIX__MaxPriceLevels swig_types[766]
#define SWIGTYPE_p_FIX__MaxPriceVariation swig_types[767]
#define SWIGTYPE_p_FIX__MaxShow swig_types[768]
#define SWIGTYPE_p_FIX__MaxTradeVol swig_types[769]
#define SWIGTYPE_p_FIX__MemoryStore swig_types[770]
#define SWIGTYPE_p_FIX__MemoryStoreFactory swig_types[771]
#define SWIGTYPE_p_FIX__Message swig_types[772]
#define SWIGTYPE_p_FIX__MessageEncoding swig_types[773]
#define SWIGTYPE_p_FIX__MessageEventSource swig_types[774]
#define SWIGTYPE_p_FIX__MessageParseError swig_types[775]
#define SWIGTYPE_p_FIX__MessageStore swig_types[776]
#define SWIGTYPE_p_FIX__MessageStoreExceptionWrapper swig_types[777]
#define SWIGTYPE_p_FIX__MessageStoreFactory swig_types[778]
#define SWIGTYPE_p_FIX__MessageStoreFactoryExceptionWrapper swig_types[779]
#define SWIGTYPE_p_FIX__MidPx swig_types[780]
#define SWIGTYPE_p_FIX__MidYield swig_types[781]
#define SWIGTYPE_p_FIX__MinBidSize swig_types[782]
#define SWIGTYPE_p_FIX__MinLotSize swig_types[783]
#define SWIGTYPE_p_FIX__MinOfferSize swig_types[784]
#define SWIGTYPE_p_FIX__MinPriceIncrement swig_types[785]
#define SWIGTYPE_p_FIX__MinPriceIncrementAmount swig_types[786]
#define SWIGTYPE_p_FIX__MinQty swig_types[787]
#define SWIGTYPE_p_FIX__MinTradeVol swig_types[788]
#define SWIGTYPE_p_FIX__MiscFeeAmt swig_types[789]
#define SWIGTYPE_p_FIX__MiscFeeBasis swig_types[790]
#define SWIGTYPE_p_FIX__MiscFeeCurr swig_types[791]
#define SWIGTYPE_p_FIX__MiscFeeType swig_types[792]
#define SWIGTYPE_p_FIX__MktBidPx swig_types[793]
#define SWIGTYPE_p_FIX__MktOfferPx swig_types[794]
#define SWIGTYPE_p_FIX__ModelType swig_types[795]
#define SWIGTYPE_p_FIX__MoneyLaunderingStatus swig_types[796]
#define SWIGTYPE_p_FIX__MsgDirection swig_types[797]
#define SWIGTYPE_p_FIX__MsgSeqNum swig_types[798]
#define SWIGTYPE_p_FIX__MsgType swig_types[799]
#define SWIGTYPE_p_FIX__MultiLegReportingType swig_types[800]
#define SWIGTYPE_p_FIX__MultiLegRptTypeReq swig_types[801]
#define SWIGTYPE_p_FIX__MultilegModel swig_types[802]
#define SWIGTYPE_p_FIX__MultilegPriceMethod swig_types[803]
#define SWIGTYPE_p_FIX__NTPositionLimit swig_types[804]
#define SWIGTYPE_p_FIX__NUMINGROUP swig_types[805]
#define SWIGTYPE_p_FIX__Nested2PartyID swig_types[806]
#define SWIGTYPE_p_FIX__Nested2PartyIDSource swig_types[807]
#define SWIGTYPE_p_FIX__Nested2PartyRole swig_types[808]
#define SWIGTYPE_p_FIX__Nested2PartySubID swig_types[809]
#define SWIGTYPE_p_FIX__Nested2PartySubIDType swig_types[810]
#define SWIGTYPE_p_FIX__Nested3PartyID swig_types[811]
#define SWIGTYPE_p_FIX__Nested3PartyIDSource swig_types[812]
#define SWIGTYPE_p_FIX__Nested3PartyRole swig_types[813]
#define SWIGTYPE_p_FIX__Nested3PartySubID swig_types[814]
#define SWIGTYPE_p_FIX__Nested3PartySubIDType swig_types[815]
#define SWIGTYPE_p_FIX__Nested4PartyID swig_types[816]
#define SWIGTYPE_p_FIX__Nested4PartyIDSource swig_types[817]
#define SWIGTYPE_p_FIX__Nested4PartyRole swig_types[818]
#define SWIGTYPE_p_FIX__Nested4PartySubID swig_types[819]
#define SWIGTYPE_p_FIX__Nested4PartySubIDType swig_types[820]
#define SWIGTYPE_p_FIX__NestedInstrAttribType swig_types[821]
#define SWIGTYPE_p_FIX__NestedInstrAttribValue swig_types[822]
#define SWIGTYPE_p_FIX__NestedPartyID swig_types[823]
#define SWIGTYPE_p_FIX__NestedPartyIDSource swig_types[824]
#define SWIGTYPE_p_FIX__NestedPartyRole swig_types[825]
#define SWIGTYPE_p_FIX__NestedPartySubID swig_types[826]
#define SWIGTYPE_p_FIX__NestedPartySubIDType swig_types[827]
#define SWIGTYPE_p_FIX__NetChgPrevDay swig_types[828]
#define SWIGTYPE_p_FIX__NetGrossInd swig_types[829]
#define SWIGTYPE_p_FIX__NetMoney swig_types[830]
#define SWIGTYPE_p_FIX__NetworkRequestID swig_types[831]
#define SWIGTYPE_p_FIX__NetworkRequestType swig_types[832]
#define SWIGTYPE_p_FIX__NetworkResponseID swig_types[833]
#define SWIGTYPE_p_FIX__NetworkStatusResponseType swig_types[834]
#define SWIGTYPE_p_FIX__NewPassword swig_types[835]
#define SWIGTYPE_p_FIX__NewSeqNo swig_types[836]
#define SWIGTYPE_p_FIX__NewsCategory swig_types[837]
#define SWIGTYPE_p_FIX__NewsID swig_types[838]
#define SWIGTYPE_p_FIX__NewsRefID swig_types[839]
#define SWIGTYPE_p_FIX__NewsRefType swig_types[840]
#define SWIGTYPE_p_FIX__NextExpectedMsgSeqNum swig_types[841]
#define SWIGTYPE_p_FIX__NoAffectedOrders swig_types[842]
#define SWIGTYPE_p_FIX__NoAllocs swig_types[843]
#define SWIGTYPE_p_FIX__NoAltMDSource swig_types[844]
#define SWIGTYPE_p_FIX__NoApplIDs swig_types[845]
#define SWIGTYPE_p_FIX__NoAsgnReqs swig_types[846]
#define SWIGTYPE_p_FIX__NoBidComponents swig_types[847]
#define SWIGTYPE_p_FIX__NoBidDescriptors swig_types[848]
#define SWIGTYPE_p_FIX__NoCapacities swig_types[849]
#define SWIGTYPE_p_FIX__NoClearingInstructions swig_types[850]
#define SWIGTYPE_p_FIX__NoCollInquiryQualifier swig_types[851]
#define SWIGTYPE_p_FIX__NoCompIDs swig_types[852]
#define SWIGTYPE_p_FIX__NoComplexEventDates swig_types[853]
#define SWIGTYPE_p_FIX__NoComplexEventTimes swig_types[854]
#define SWIGTYPE_p_FIX__NoComplexEvents swig_types[855]
#define SWIGTYPE_p_FIX__NoContAmts swig_types[856]
#define SWIGTYPE_p_FIX__NoContraBrokers swig_types[857]
#define SWIGTYPE_p_FIX__NoDates swig_types[858]
#define SWIGTYPE_p_FIX__NoDerivativeEvents swig_types[859]
#define SWIGTYPE_p_FIX__NoDerivativeInstrAttrib swig_types[860]
#define SWIGTYPE_p_FIX__NoDerivativeInstrumentParties swig_types[861]
#define SWIGTYPE_p_FIX__NoDerivativeInstrumentPartySubIDs swig_types[862]
#define SWIGTYPE_p_FIX__NoDerivativeSecurityAltID swig_types[863]
#define SWIGTYPE_p_FIX__NoDistribInsts swig_types[864]
#define SWIGTYPE_p_FIX__NoDlvyInst swig_types[865]
#define SWIGTYPE_p_FIX__NoEvents swig_types[866]
#define SWIGTYPE_p_FIX__NoExecInstRules swig_types[867]
#define SWIGTYPE_p_FIX__NoExecs swig_types[868]
#define SWIGTYPE_p_FIX__NoExpiration swig_types[869]
#define SWIGTYPE_p_FIX__NoFills swig_types[870]
#define SWIGTYPE_p_FIX__NoHops swig_types[871]
#define SWIGTYPE_p_FIX__NoIOIQualifiers swig_types[872]
#define SWIGTYPE_p_FIX__NoInstrAttrib swig_types[873]
#define SWIGTYPE_p_FIX__NoInstrumentParties swig_types[874]
#define SWIGTYPE_p_FIX__NoInstrumentPartySubIDs swig_types[875]
#define SWIGTYPE_p_FIX__NoLegAllocs swig_types[876]
#define SWIGTYPE_p_FIX__NoLegSecurityAltID swig_types[877]
#define SWIGTYPE_p_FIX__NoLegStipulations swig_types[878]
#define SWIGTYPE_p_FIX__NoLegs swig_types[879]
#define SWIGTYPE_p_FIX__NoLinesOfText swig_types[880]
#define SWIGTYPE_p_FIX__NoLotTypeRules swig_types[881]
#define SWIGTYPE_p_FIX__NoMDEntries swig_types[882]
#define SWIGTYPE_p_FIX__NoMDEntryTypes swig_types[883]
#define SWIGTYPE_p_FIX__NoMDFeedTypes swig_types[884]
#define SWIGTYPE_p_FIX__NoMarketSegments swig_types[885]
#define SWIGTYPE_p_FIX__NoMatchRules swig_types[886]
#define SWIGTYPE_p_FIX__NoMaturityRules swig_types[887]
#define SWIGTYPE_p_FIX__NoMiscFees swig_types[888]
#define SWIGTYPE_p_FIX__NoMsgTypes swig_types[889]
#define SWIGTYPE_p_FIX__NoNested2PartyIDs swig_types[890]
#define SWIGTYPE_p_FIX__NoNested2PartySubIDs swig_types[891]
#define SWIGTYPE_p_FIX__NoNested3PartyIDs swig_types[892]
#define SWIGTYPE_p_FIX__NoNested3PartySubIDs swig_types[893]
#define SWIGTYPE_p_FIX__NoNested4PartyIDs swig_types[894]
#define SWIGTYPE_p_FIX__NoNested4PartySubIDs swig_types[895]
#define SWIGTYPE_p_FIX__NoNestedInstrAttrib swig_types[896]
#define SWIGTYPE_p_FIX__NoNestedPartyIDs swig_types[897]
#define SWIGTYPE_p_FIX__NoNestedPartySubIDs swig_types[898]
#define SWIGTYPE_p_FIX__NoNewsRefIDs swig_types[899]
#define SWIGTYPE_p_FIX__NoNotAffectedOrders swig_types[900]
#define SWIGTYPE_p_FIX__NoOfLegUnderlyings swig_types[901]
#define SWIGTYPE_p_FIX__NoOfSecSizes swig_types[902]
#define SWIGTYPE_p_FIX__NoOrdTypeRules swig_types[903]
#define SWIGTYPE_p_FIX__NoOrders swig_types[904]
#define SWIGTYPE_p_FIX__NoPartyIDs swig_types[905]
#define SWIGTYPE_p_FIX__NoPartySubIDs swig_types[906]
#define SWIGTYPE_p_FIX__NoPosAmt swig_types[907]
#define SWIGTYPE_p_FIX__NoPositions swig_types[908]
#define SWIGTYPE_p_FIX__NoQuoteEntries swig_types[909]
#define SWIGTYPE_p_FIX__NoQuoteQualifiers swig_types[910]
#define SWIGTYPE_p_FIX__NoQuoteSets swig_types[911]
#define SWIGTYPE_p_FIX__NoRateSources swig_types[912]
#define SWIGTYPE_p_FIX__NoRegistDtls swig_types[913]
#define SWIGTYPE_p_FIX__NoRelatedSym swig_types[914]
#define SWIGTYPE_p_FIX__NoRootPartyIDs swig_types[915]
#define SWIGTYPE_p_FIX__NoRootPartySubIDs swig_types[916]
#define SWIGTYPE_p_FIX__NoRoutingIDs swig_types[917]
#define SWIGTYPE_p_FIX__NoRpts swig_types[918]
#define SWIGTYPE_p_FIX__NoSecurityAltID swig_types[919]
#define SWIGTYPE_p_FIX__NoSecurityTypes swig_types[920]
#define SWIGTYPE_p_FIX__NoSettlDetails swig_types[921]
#define SWIGTYPE_p_FIX__NoSettlInst swig_types[922]
#define SWIGTYPE_p_FIX__NoSettlOblig swig_types[923]
#define SWIGTYPE_p_FIX__NoSettlPartyIDs swig_types[924]
#define SWIGTYPE_p_FIX__NoSettlPartySubIDs swig_types[925]
#define SWIGTYPE_p_FIX__NoSideTrdRegTS swig_types[926]
#define SWIGTYPE_p_FIX__NoSides swig_types[927]
#define SWIGTYPE_p_FIX__NoStatsIndicators swig_types[928]
#define SWIGTYPE_p_FIX__NoStipulations swig_types[929]
#define SWIGTYPE_p_FIX__NoStrategyParameters swig_types[930]
#define SWIGTYPE_p_FIX__NoStrikeRules swig_types[931]
#define SWIGTYPE_p_FIX__NoStrikes swig_types[932]
#define SWIGTYPE_p_FIX__NoTagValue swig_types[933]
#define SWIGTYPE_p_FIX__NoTargetPartyIDs swig_types[934]
#define SWIGTYPE_p_FIX__NoTickRules swig_types[935]
#define SWIGTYPE_p_FIX__NoTimeInForceRules swig_types[936]
#define SWIGTYPE_p_FIX__NoTrades swig_types[937]
#define SWIGTYPE_p_FIX__NoTradingSessionRules swig_types[938]
#define SWIGTYPE_p_FIX__NoTradingSessions swig_types[939]
#define SWIGTYPE_p_FIX__NoTrdRegTimestamps swig_types[940]
#define SWIGTYPE_p_FIX__NoTrdRepIndicators swig_types[941]
#define SWIGTYPE_p_FIX__NoUnderlyingAmounts swig_types[942]
#define SWIGTYPE_p_FIX__NoUnderlyingLegSecurityAltID swig_types[943]
#define SWIGTYPE_p_FIX__NoUnderlyingSecurityAltID swig_types[944]
#define SWIGTYPE_p_FIX__NoUnderlyingStips swig_types[945]
#define SWIGTYPE_p_FIX__NoUnderlyings swig_types[946]
#define SWIGTYPE_p_FIX__NoUndlyInstrumentParties swig_types[947]
#define SWIGTYPE_p_FIX__NoUndlyInstrumentPartySubIDs swig_types[948]
#define SWIGTYPE_p_FIX__NotAffOrigClOrdID swig_types[949]
#define SWIGTYPE_p_FIX__NotAffectedOrderID swig_types[950]
#define SWIGTYPE_p_FIX__NotifyBrokerOfCredit swig_types[951]
#define SWIGTYPE_p_FIX__NotionalPercentageOutstanding swig_types[952]
#define SWIGTYPE_p_FIX__NullApplication swig_types[953]
#define SWIGTYPE_p_FIX__NullLog swig_types[954]
#define SWIGTYPE_p_FIX__NumBidders swig_types[955]
#define SWIGTYPE_p_FIX__NumDaysInterest swig_types[956]
#define SWIGTYPE_p_FIX__NumTickets swig_types[957]
#define SWIGTYPE_p_FIX__NumberOfOrders swig_types[958]
#define SWIGTYPE_p_FIX__OddLot swig_types[959]
#define SWIGTYPE_p_FIX__OfferForwardPoints swig_types[960]
#define SWIGTYPE_p_FIX__OfferForwardPoints2 swig_types[961]
#define SWIGTYPE_p_FIX__OfferPx swig_types[962]
#define SWIGTYPE_p_FIX__OfferSize swig_types[963]
#define SWIGTYPE_p_FIX__OfferSpotRate swig_types[964]
#define SWIGTYPE_p_FIX__OfferSwapPoints swig_types[965]
#define SWIGTYPE_p_FIX__OfferYield swig_types[966]
#define SWIGTYPE_p_FIX__OnBehalfOfCompID swig_types[967]
#define SWIGTYPE_p_FIX__OnBehalfOfLocationID swig_types[968]
#define SWIGTYPE_p_FIX__OnBehalfOfSendingTime swig_types[969]
#define SWIGTYPE_p_FIX__OnBehalfOfSubID swig_types[970]
#define SWIGTYPE_p_FIX__OpenClose swig_types[971]
#define SWIGTYPE_p_FIX__OpenCloseSettlFlag swig_types[972]
#define SWIGTYPE_p_FIX__OpenCloseSettleFlag swig_types[973]
#define SWIGTYPE_p_FIX__OpenInterest swig_types[974]
#define SWIGTYPE_p_FIX__OptAttribute swig_types[975]
#define SWIGTYPE_p_FIX__OptPayAmount swig_types[976]
#define SWIGTYPE_p_FIX__OptPayoutAmount swig_types[977]
#define SWIGTYPE_p_FIX__OptPayoutType swig_types[978]
#define SWIGTYPE_p_FIX__OrdRejReason swig_types[979]
#define SWIGTYPE_p_FIX__OrdStatus swig_types[980]
#define SWIGTYPE_p_FIX__OrdStatusReqID swig_types[981]
#define SWIGTYPE_p_FIX__OrdType swig_types[982]
#define SWIGTYPE_p_FIX__OrderAvgPx swig_types[983]
#define SWIGTYPE_p_FIX__OrderBookingQty swig_types[984]
#define SWIGTYPE_p_FIX__OrderCapacity swig_types[985]
#define SWIGTYPE_p_FIX__OrderCapacityQty swig_types[986]
#define SWIGTYPE_p_FIX__OrderCategory swig_types[987]
#define SWIGTYPE_p_FIX__OrderDelay swig_types[988]
#define SWIGTYPE_p_FIX__OrderDelayUnit swig_types[989]
#define SWIGTYPE_p_FIX__OrderHandlingInstSource swig_types[990]
#define SWIGTYPE_p_FIX__OrderID swig_types[991]
#define SWIGTYPE_p_FIX__OrderInputDevice swig_types[992]
#define SWIGTYPE_p_FIX__OrderPercent swig_types[993]
#define SWIGTYPE_p_FIX__OrderQty swig_types[994]
#define SWIGTYPE_p_FIX__OrderQty2 swig_types[995]
#define SWIGTYPE_p_FIX__OrderRestrictions swig_types[996]
#define SWIGTYPE_p_FIX__OrigClOrdID swig_types[997]
#define SWIGTYPE_p_FIX__OrigCrossID swig_types[998]
#define SWIGTYPE_p_FIX__OrigCustOrderCapacity swig_types[999]
#define SWIGTYPE_p_FIX__OrigOrdModTime swig_types[1000]
#define SWIGTYPE_p_FIX__OrigPosReqRefID swig_types[1001]
#define SWIGTYPE_p_FIX__OrigSecondaryTradeID swig_types[1002]
#define SWIGTYPE_p_FIX__OrigSendingTime swig_types[1003]
#define SWIGTYPE_p_FIX__OrigTime swig_types[1004]
#define SWIGTYPE_p_FIX__OrigTradeDate swig_types[1005]
#define SWIGTYPE_p_FIX__OrigTradeHandlingInstr swig_types[1006]
#define SWIGTYPE_p_FIX__OrigTradeID swig_types[1007]
#define SWIGTYPE_p_FIX__OriginalNotionalPercentageOutstanding swig_types[1008]
#define SWIGTYPE_p_FIX__OutMainCntryUIndex swig_types[1009]
#define SWIGTYPE_p_FIX__OutsideIndexPct swig_types[1010]
#define SWIGTYPE_p_FIX__OwnerType swig_types[1011]
#define SWIGTYPE_p_FIX__OwnershipType swig_types[1012]
#define SWIGTYPE_p_FIX__PERCENTAGE swig_types[1013]
#define SWIGTYPE_p_FIX__PRICE swig_types[1014]
#define SWIGTYPE_p_FIX__PRICEOFFSET swig_types[1015]
#define SWIGTYPE_p_FIX__ParentMktSegmID swig_types[1016]
#define SWIGTYPE_p_FIX__ParticipationRate swig_types[1017]
#define SWIGTYPE_p_FIX__PartyID swig_types[1018]
#define SWIGTYPE_p_FIX__PartyIDSource swig_types[1019]
#define SWIGTYPE_p_FIX__PartyRole swig_types[1020]
#define SWIGTYPE_p_FIX__PartySubID swig_types[1021]
#define SWIGTYPE_p_FIX__PartySubIDType swig_types[1022]
#define SWIGTYPE_p_FIX__Password swig_types[1023]
#define SWIGTYPE_p_FIX__PaymentDate swig_types[1024]
#define SWIGTYPE_p_FIX__PaymentMethod swig_types[1025]
#define SWIGTYPE_p_FIX__PaymentRef swig_types[1026]
#define SWIGTYPE_p_FIX__PaymentRemitterID swig_types[1027]
#define SWIGTYPE_p_FIX__PctAtRisk swig_types[1028]
#define SWIGTYPE_p_FIX__PegDifference swig_types[1029]
#define SWIGTYPE_p_FIX__PegLimitType swig_types[1030]
#define SWIGTYPE_p_FIX__PegMoveType swig_types[1031]
#define SWIGTYPE_p_FIX__PegOffsetType swig_types[1032]
#define SWIGTYPE_p_FIX__PegOffsetValue swig_types[1033]
#define SWIGTYPE_p_FIX__PegPriceType swig_types[1034]
#define SWIGTYPE_p_FIX__PegRoundDirection swig_types[1035]
#define SWIGTYPE_p_FIX__PegScope swig_types[1036]
#define SWIGTYPE_p_FIX__PegSecurityDesc swig_types[1037]
#define SWIGTYPE_p_FIX__PegSecurityID swig_types[1038]
#define SWIGTYPE_p_FIX__PegSecurityIDSource swig_types[1039]
#define SWIGTYPE_p_FIX__PegSymbol swig_types[1040]
#define SWIGTYPE_p_FIX__PeggedPrice swig_types[1041]
#define SWIGTYPE_p_FIX__PeggedRefPrice swig_types[1042]
#define SWIGTYPE_p_FIX__Pool swig_types[1043]
#define SWIGTYPE_p_FIX__PosAmt swig_types[1044]
#define SWIGTYPE_p_FIX__PosAmtType swig_types[1045]
#define SWIGTYPE_p_FIX__PosMaintAction swig_types[1046]
#define SWIGTYPE_p_FIX__PosMaintResult swig_types[1047]
#define SWIGTYPE_p_FIX__PosMaintRptID swig_types[1048]
#define SWIGTYPE_p_FIX__PosMaintRptRefID swig_types[1049]
#define SWIGTYPE_p_FIX__PosMaintStatus swig_types[1050]
#define SWIGTYPE_p_FIX__PosQtyStatus swig_types[1051]
#define SWIGTYPE_p_FIX__PosReqID swig_types[1052]
#define SWIGTYPE_p_FIX__PosReqResult swig_types[1053]
#define SWIGTYPE_p_FIX__PosReqStatus swig_types[1054]
#define SWIGTYPE_p_FIX__PosReqType swig_types[1055]
#define SWIGTYPE_p_FIX__PosTransType swig_types[1056]
#define SWIGTYPE_p_FIX__PosType swig_types[1057]
#define SWIGTYPE_p_FIX__PositionCurrency swig_types[1058]
#define SWIGTYPE_p_FIX__PositionEffect swig_types[1059]
#define SWIGTYPE_p_FIX__PositionLimit swig_types[1060]
#define SWIGTYPE_p_FIX__PossDupFlag swig_types[1061]
#define SWIGTYPE_p_FIX__PossResend swig_types[1062]
#define SWIGTYPE_p_FIX__PreTradeAnonymity swig_types[1063]
#define SWIGTYPE_p_FIX__PreallocMethod swig_types[1064]
#define SWIGTYPE_p_FIX__PrevClosePx swig_types[1065]
#define SWIGTYPE_p_FIX__PreviouslyReported swig_types[1066]
#define SWIGTYPE_p_FIX__Price swig_types[1067]
#define SWIGTYPE_p_FIX__Price2 swig_types[1068]
#define SWIGTYPE_p_FIX__PriceDelta swig_types[1069]
#define SWIGTYPE_p_FIX__PriceImprovement swig_types[1070]
#define SWIGTYPE_p_FIX__PriceLimitType swig_types[1071]
#define SWIGTYPE_p_FIX__PriceProtectionScope swig_types[1072]
#define SWIGTYPE_p_FIX__PriceQuoteMethod swig_types[1073]
#define SWIGTYPE_p_FIX__PriceType swig_types[1074]
#define SWIGTYPE_p_FIX__PriceUnitOfMeasure swig_types[1075]
#define SWIGTYPE_p_FIX__PriceUnitOfMeasureQty swig_types[1076]
#define SWIGTYPE_p_FIX__PriorSettlPrice swig_types[1077]
#define SWIGTYPE_p_FIX__PriorSpreadIndicator swig_types[1078]
#define SWIGTYPE_p_FIX__PriorityIndicator swig_types[1079]
#define SWIGTYPE_p_FIX__PrivateQuote swig_types[1080]
#define SWIGTYPE_p_FIX__ProcessCode swig_types[1081]
#define SWIGTYPE_p_FIX__Product swig_types[1082]
#define SWIGTYPE_p_FIX__ProductComplex swig_types[1083]
#define SWIGTYPE_p_FIX__ProgPeriodInterval swig_types[1084]
#define SWIGTYPE_p_FIX__ProgRptReqs swig_types[1085]
#define SWIGTYPE_p_FIX__PublishTrdIndicator swig_types[1086]
#define SWIGTYPE_p_FIX__PutOrCall swig_types[1087]
#define SWIGTYPE_p_FIX__QTY swig_types[1088]
#define SWIGTYPE_p_FIX__QtyType swig_types[1089]
#define SWIGTYPE_p_FIX__Quantity swig_types[1090]
#define SWIGTYPE_p_FIX__QuantityDate swig_types[1091]
#define SWIGTYPE_p_FIX__QuantityType swig_types[1092]
#define SWIGTYPE_p_FIX__QuoteAckStatus swig_types[1093]
#define SWIGTYPE_p_FIX__QuoteCancelType swig_types[1094]
#define SWIGTYPE_p_FIX__QuoteCondition swig_types[1095]
#define SWIGTYPE_p_FIX__QuoteEntryID swig_types[1096]
#define SWIGTYPE_p_FIX__QuoteEntryRejectReason swig_types[1097]
#define SWIGTYPE_p_FIX__QuoteEntryStatus swig_types[1098]
#define SWIGTYPE_p_FIX__QuoteID swig_types[1099]
#define SWIGTYPE_p_FIX__QuoteMsgID swig_types[1100]
#define SWIGTYPE_p_FIX__QuotePriceType swig_types[1101]
#define SWIGTYPE_p_FIX__QuoteQualifier swig_types[1102]
#define SWIGTYPE_p_FIX__QuoteRejectReason swig_types[1103]
#define SWIGTYPE_p_FIX__QuoteReqID swig_types[1104]
#define SWIGTYPE_p_FIX__QuoteRequestRejectReason swig_types[1105]
#define SWIGTYPE_p_FIX__QuoteRequestType swig_types[1106]
#define SWIGTYPE_p_FIX__QuoteRespID swig_types[1107]
#define SWIGTYPE_p_FIX__QuoteRespType swig_types[1108]
#define SWIGTYPE_p_FIX__QuoteResponseLevel swig_types[1109]
#define SWIGTYPE_p_FIX__QuoteSetID swig_types[1110]
#define SWIGTYPE_p_FIX__QuoteSetValidUntilTime swig_types[1111]
#define SWIGTYPE_p_FIX__QuoteStatus swig_types[1112]
#define SWIGTYPE_p_FIX__QuoteStatusReqID swig_types[1113]
#define SWIGTYPE_p_FIX__QuoteType swig_types[1114]
#define SWIGTYPE_p_FIX__RFQReqID swig_types[1115]
#define SWIGTYPE_p_FIX__RateSource swig_types[1116]
#define SWIGTYPE_p_FIX__RateSourceType swig_types[1117]
#define SWIGTYPE_p_FIX__RatioQty swig_types[1118]
#define SWIGTYPE_p_FIX__RawData swig_types[1119]
#define SWIGTYPE_p_FIX__RawDataLength swig_types[1120]
#define SWIGTYPE_p_FIX__ReceivedDeptID swig_types[1121]
#define SWIGTYPE_p_FIX__RedemptionDate swig_types[1122]
#define SWIGTYPE_p_FIX__RefAllocID swig_types[1123]
#define SWIGTYPE_p_FIX__RefApplExtID swig_types[1124]
#define SWIGTYPE_p_FIX__RefApplID swig_types[1125]
#define SWIGTYPE_p_FIX__RefApplLastSeqNum swig_types[1126]
#define SWIGTYPE_p_FIX__RefApplReqID swig_types[1127]
#define SWIGTYPE_p_FIX__RefApplVerID swig_types[1128]
#define SWIGTYPE_p_FIX__RefCompID swig_types[1129]
#define SWIGTYPE_p_FIX__RefCstmApplVerID swig_types[1130]
#define SWIGTYPE_p_FIX__RefMsgType swig_types[1131]
#define SWIGTYPE_p_FIX__RefOrdIDReason swig_types[1132]
#define SWIGTYPE_p_FIX__RefOrderID swig_types[1133]
#define SWIGTYPE_p_FIX__RefOrderIDSource swig_types[1134]
#define SWIGTYPE_p_FIX__RefSeqNum swig_types[1135]
#define SWIGTYPE_p_FIX__RefSubID swig_types[1136]
#define SWIGTYPE_p_FIX__RefTagID swig_types[1137]
#define SWIGTYPE_p_FIX__ReferencePage swig_types[1138]
#define SWIGTYPE_p_FIX__RefreshIndicator swig_types[1139]
#define SWIGTYPE_p_FIX__RefreshQty swig_types[1140]
#define SWIGTYPE_p_FIX__RegistAcctType swig_types[1141]
#define SWIGTYPE_p_FIX__RegistDetls swig_types[1142]
#define SWIGTYPE_p_FIX__RegistDtls swig_types[1143]
#define SWIGTYPE_p_FIX__RegistEmail swig_types[1144]
#define SWIGTYPE_p_FIX__RegistID swig_types[1145]
#define SWIGTYPE_p_FIX__RegistRefID swig_types[1146]
#define SWIGTYPE_p_FIX__RegistRejReasonCode swig_types[1147]
#define SWIGTYPE_p_FIX__RegistRejReasonText swig_types[1148]
#define SWIGTYPE_p_FIX__RegistStatus swig_types[1149]
#define SWIGTYPE_p_FIX__RegistTransType swig_types[1150]
#define SWIGTYPE_p_FIX__RejectLogon swig_types[1151]
#define SWIGTYPE_p_FIX__RejectText swig_types[1152]
#define SWIGTYPE_p_FIX__RelSymTransactTime swig_types[1153]
#define SWIGTYPE_p_FIX__RelatdSym swig_types[1154]
#define SWIGTYPE_p_FIX__RepeatedTag swig_types[1155]
#define SWIGTYPE_p_FIX__RepeatingGroupCountMismatch swig_types[1156]
#define SWIGTYPE_p_FIX__RepoCollateralSecurityType swig_types[1157]
#define SWIGTYPE_p_FIX__ReportToExch swig_types[1158]
#define SWIGTYPE_p_FIX__ReportedPx swig_types[1159]
#define SWIGTYPE_p_FIX__ReportedPxDiff swig_types[1160]
#define SWIGTYPE_p_FIX__RepurchaseRate swig_types[1161]
#define SWIGTYPE_p_FIX__RepurchaseTerm swig_types[1162]
#define SWIGTYPE_p_FIX__RequiredTagMissing swig_types[1163]
#define SWIGTYPE_p_FIX__ResetSeqNumFlag swig_types[1164]
#define SWIGTYPE_p_FIX__RespondentType swig_types[1165]
#define SWIGTYPE_p_FIX__ResponseDestination swig_types[1166]
#define SWIGTYPE_p_FIX__ResponseTransportType swig_types[1167]
#define SWIGTYPE_p_FIX__RestructuringType swig_types[1168]
#define SWIGTYPE_p_FIX__ReversalIndicator swig_types[1169]
#define SWIGTYPE_p_FIX__RiskFreeRate swig_types[1170]
#define SWIGTYPE_p_FIX__RndPx swig_types[1171]
#define SWIGTYPE_p_FIX__RootPartyID swig_types[1172]
#define SWIGTYPE_p_FIX__RootPartyIDSource swig_types[1173]
#define SWIGTYPE_p_FIX__RootPartyRole swig_types[1174]
#define SWIGTYPE_p_FIX__RootPartySubID swig_types[1175]
#define SWIGTYPE_p_FIX__RootPartySubIDType swig_types[1176]
#define SWIGTYPE_p_FIX__RoundLot swig_types[1177]
#define SWIGTYPE_p_FIX__RoundingDirection swig_types[1178]
#define SWIGTYPE_p_FIX__RoundingModulus swig_types[1179]
#define SWIGTYPE_p_FIX__RoutingID swig_types[1180]
#define SWIGTYPE_p_FIX__RoutingType swig_types[1181]
#define SWIGTYPE_p_FIX__RptSeq swig_types[1182]
#define SWIGTYPE_p_FIX__RptSys swig_types[1183]
#define SWIGTYPE_p_FIX__Rule80A swig_types[1184]
#define SWIGTYPE_p_FIX__RuntimeError swig_types[1185]
#define SWIGTYPE_p_FIX__SEQNUM swig_types[1186]
#define SWIGTYPE_p_FIX__STRING swig_types[1187]
#define SWIGTYPE_p_FIX__Scope swig_types[1188]
#define SWIGTYPE_p_FIX__ScreenLog swig_types[1189]
#define SWIGTYPE_p_FIX__ScreenLogFactory swig_types[1190]
#define SWIGTYPE_p_FIX__SecondaryAllocID swig_types[1191]
#define SWIGTYPE_p_FIX__SecondaryClOrdID swig_types[1192]
#define SWIGTYPE_p_FIX__SecondaryDisplayQty swig_types[1193]
#define SWIGTYPE_p_FIX__SecondaryExecID swig_types[1194]
#define SWIGTYPE_p_FIX__SecondaryFirmTradeID swig_types[1195]
#define SWIGTYPE_p_FIX__SecondaryHighLimitPrice swig_types[1196]
#define SWIGTYPE_p_FIX__SecondaryIndividualAllocID swig_types[1197]
#define SWIGTYPE_p_FIX__SecondaryLowLimitPrice swig_types[1198]
#define SWIGTYPE_p_FIX__SecondaryOrderID swig_types[1199]
#define SWIGTYPE_p_FIX__SecondaryPriceLimitType swig_types[1200]
#define SWIGTYPE_p_FIX__SecondaryTradeID swig_types[1201]
#define SWIGTYPE_p_FIX__SecondaryTradeReportID swig_types[1202]
#define SWIGTYPE_p_FIX__SecondaryTradeReportRefID swig_types[1203]
#define SWIGTYPE_p_FIX__SecondaryTradingReferencePrice swig_types[1204]
#define SWIGTYPE_p_FIX__SecondaryTrdType swig_types[1205]
#define SWIGTYPE_p_FIX__SecureData swig_types[1206]
#define SWIGTYPE_p_FIX__SecureDataLen swig_types[1207]
#define SWIGTYPE_p_FIX__SecurityAltID swig_types[1208]
#define SWIGTYPE_p_FIX__SecurityAltIDSource swig_types[1209]
#define SWIGTYPE_p_FIX__SecurityDesc swig_types[1210]
#define SWIGTYPE_p_FIX__SecurityExchange swig_types[1211]
#define SWIGTYPE_p_FIX__SecurityGroup swig_types[1212]
#define SWIGTYPE_p_FIX__SecurityID swig_types[1213]
#define SWIGTYPE_p_FIX__SecurityIDSource swig_types[1214]
#define SWIGTYPE_p_FIX__SecurityListDesc swig_types[1215]
#define SWIGTYPE_p_FIX__SecurityListID swig_types[1216]
#define SWIGTYPE_p_FIX__SecurityListRefID swig_types[1217]
#define SWIGTYPE_p_FIX__SecurityListRequestType swig_types[1218]
#define SWIGTYPE_p_FIX__SecurityListType swig_types[1219]
#define SWIGTYPE_p_FIX__SecurityListTypeSource swig_types[1220]
#define SWIGTYPE_p_FIX__SecurityReportID swig_types[1221]
#define SWIGTYPE_p_FIX__SecurityReqID swig_types[1222]
#define SWIGTYPE_p_FIX__SecurityRequestResult swig_types[1223]
#define SWIGTYPE_p_FIX__SecurityRequestType swig_types[1224]
#define SWIGTYPE_p_FIX__SecurityResponseID swig_types[1225]
#define SWIGTYPE_p_FIX__SecurityResponseType swig_types[1226]
#define SWIGTYPE_p_FIX__SecuritySettlAgentAcctName swig_types[1227]
#define SWIGTYPE_p_FIX__SecuritySettlAgentAcctNum swig_types[1228]
#define SWIGTYPE_p_FIX__SecuritySettlAgentCode swig_types[1229]
#define SWIGTYPE_p_FIX__SecuritySettlAgentContactName swig_types[1230]
#define SWIGTYPE_p_FIX__SecuritySettlAgentContactPhone swig_types[1231]
#define SWIGTYPE_p_FIX__SecuritySettlAgentName swig_types[1232]
#define SWIGTYPE_p_FIX__SecurityStatus swig_types[1233]
#define SWIGTYPE_p_FIX__SecurityStatusReqID swig_types[1234]
#define SWIGTYPE_p_FIX__SecuritySubType swig_types[1235]
#define SWIGTYPE_p_FIX__SecurityTradingEvent swig_types[1236]
#define SWIGTYPE_p_FIX__SecurityTradingStatus swig_types[1237]
#define SWIGTYPE_p_FIX__SecurityType swig_types[1238]
#define SWIGTYPE_p_FIX__SecurityUpdateAction swig_types[1239]
#define SWIGTYPE_p_FIX__SecurityXML swig_types[1240]
#define SWIGTYPE_p_FIX__SecurityXMLLen swig_types[1241]
#define SWIGTYPE_p_FIX__SecurityXMLSchema swig_types[1242]
#define SWIGTYPE_p_FIX__SellVolume swig_types[1243]
#define SWIGTYPE_p_FIX__SellerDays swig_types[1244]
#define SWIGTYPE_p_FIX__SenderCompID swig_types[1245]
#define SWIGTYPE_p_FIX__SenderLocationID swig_types[1246]
#define SWIGTYPE_p_FIX__SenderSubID swig_types[1247]
#define SWIGTYPE_p_FIX__SendingDate swig_types[1248]
#define SWIGTYPE_p_FIX__SendingTime swig_types[1249]
#define SWIGTYPE_p_FIX__Seniority swig_types[1250]
#define SWIGTYPE_p_FIX__Session swig_types[1251]
#define SWIGTYPE_p_FIX__SessionID swig_types[1252]
#define SWIGTYPE_p_FIX__SessionNotFound swig_types[1253]
#define SWIGTYPE_p_FIX__SessionRejectReason swig_types[1254]
#define SWIGTYPE_p_FIX__SessionSettings swig_types[1255]
#define SWIGTYPE_p_FIX__SessionStatus swig_types[1256]
#define SWIGTYPE_p_FIX__SettlBrkrCode swig_types[1257]
#define SWIGTYPE_p_FIX__SettlCurrAmt swig_types[1258]
#define SWIGTYPE_p_FIX__SettlCurrBidFxRate swig_types[1259]
#define SWIGTYPE_p_FIX__SettlCurrFxRate swig_types[1260]
#define SWIGTYPE_p_FIX__SettlCurrFxRateCalc swig_types[1261]
#define SWIGTYPE_p_FIX__SettlCurrOfferFxRate swig_types[1262]
#define SWIGTYPE_p_FIX__SettlCurrency swig_types[1263]
#define SWIGTYPE_p_FIX__SettlDate swig_types[1264]
#define SWIGTYPE_p_FIX__SettlDate2 swig_types[1265]
#define SWIGTYPE_p_FIX__SettlDeliveryType swig_types[1266]
#define SWIGTYPE_p_FIX__SettlDepositoryCode swig_types[1267]
#define SWIGTYPE_p_FIX__SettlInstCode swig_types[1268]
#define SWIGTYPE_p_FIX__SettlInstID swig_types[1269]
#define SWIGTYPE_p_FIX__SettlInstMode swig_types[1270]
#define SWIGTYPE_p_FIX__SettlInstMsgID swig_types[1271]
#define SWIGTYPE_p_FIX__SettlInstRefID swig_types[1272]
#define SWIGTYPE_p_FIX__SettlInstReqID swig_types[1273]
#define SWIGTYPE_p_FIX__SettlInstReqRejCode swig_types[1274]
#define SWIGTYPE_p_FIX__SettlInstSource swig_types[1275]
#define SWIGTYPE_p_FIX__SettlInstTransType swig_types[1276]
#define SWIGTYPE_p_FIX__SettlLocation swig_types[1277]
#define SWIGTYPE_p_FIX__SettlMethod swig_types[1278]
#define SWIGTYPE_p_FIX__SettlObligID swig_types[1279]
#define SWIGTYPE_p_FIX__SettlObligMode swig_types[1280]
#define SWIGTYPE_p_FIX__SettlObligMsgID swig_types[1281]
#define SWIGTYPE_p_FIX__SettlObligRefID swig_types[1282]
#define SWIGTYPE_p_FIX__SettlObligSource swig_types[1283]
#define SWIGTYPE_p_FIX__SettlObligTransType swig_types[1284]
#define SWIGTYPE_p_FIX__SettlPartyID swig_types[1285]
#define SWIGTYPE_p_FIX__SettlPartyIDSource swig_types[1286]
#define SWIGTYPE_p_FIX__SettlPartyRole swig_types[1287]
#define SWIGTYPE_p_FIX__SettlPartySubID swig_types[1288]
#define SWIGTYPE_p_FIX__SettlPartySubIDType swig_types[1289]
#define SWIGTYPE_p_FIX__SettlPrice swig_types[1290]
#define SWIGTYPE_p_FIX__SettlPriceType swig_types[1291]
#define SWIGTYPE_p_FIX__SettlSessID swig_types[1292]
#define SWIGTYPE_p_FIX__SettlSessSubID swig_types[1293]
#define SWIGTYPE_p_FIX__SettlType swig_types[1294]
#define SWIGTYPE_p_FIX__SettleOnOpenFlag swig_types[1295]
#define SWIGTYPE_p_FIX__SettlementCycleNo swig_types[1296]
#define SWIGTYPE_p_FIX__SettlmntTyp swig_types[1297]
#define SWIGTYPE_p_FIX__SharedCommission swig_types[1298]
#define SWIGTYPE_p_FIX__Shares swig_types[1299]
#define SWIGTYPE_p_FIX__ShortQty swig_types[1300]
#define SWIGTYPE_p_FIX__ShortSaleReason swig_types[1301]
#define SWIGTYPE_p_FIX__Side swig_types[1302]
#define SWIGTYPE_p_FIX__SideComplianceID swig_types[1303]
#define SWIGTYPE_p_FIX__SideCurrency swig_types[1304]
#define SWIGTYPE_p_FIX__SideExecID swig_types[1305]
#define SWIGTYPE_p_FIX__SideFillStationCd swig_types[1306]
#define SWIGTYPE_p_FIX__SideGrossTradeAmt swig_types[1307]
#define SWIGTYPE_p_FIX__SideLastQty swig_types[1308]
#define SWIGTYPE_p_FIX__SideLiquidityInd swig_types[1309]
#define SWIGTYPE_p_FIX__SideMultiLegReportingType swig_types[1310]
#define SWIGTYPE_p_FIX__SideQty swig_types[1311]
#define SWIGTYPE_p_FIX__SideReasonCd swig_types[1312]
#define SWIGTYPE_p_FIX__SideSettlCurrency swig_types[1313]
#define SWIGTYPE_p_FIX__SideTimeInForce swig_types[1314]
#define SWIGTYPE_p_FIX__SideTradeReportID swig_types[1315]
#define SWIGTYPE_p_FIX__SideTrdRegTimestamp swig_types[1316]
#define SWIGTYPE_p_FIX__SideTrdRegTimestampSrc swig_types[1317]
#define SWIGTYPE_p_FIX__SideTrdRegTimestampType swig_types[1318]
#define SWIGTYPE_p_FIX__SideTrdSubTyp swig_types[1319]
#define SWIGTYPE_p_FIX__SideValue1 swig_types[1320]
#define SWIGTYPE_p_FIX__SideValue2 swig_types[1321]
#define SWIGTYPE_p_FIX__SideValueInd swig_types[1322]
#define SWIGTYPE_p_FIX__Signature swig_types[1323]
#define SWIGTYPE_p_FIX__SignatureLength swig_types[1324]
#define SWIGTYPE_p_FIX__SocketAcceptor swig_types[1325]
#define SWIGTYPE_p_FIX__SocketCloseFailed swig_types[1326]
#define SWIGTYPE_p_FIX__SocketException swig_types[1327]
#define SWIGTYPE_p_FIX__SocketInitiator swig_types[1328]
#define SWIGTYPE_p_FIX__SocketRecvFailed swig_types[1329]
#define SWIGTYPE_p_FIX__SocketSendFailed swig_types[1330]
#define SWIGTYPE_p_FIX__SolicitedFlag swig_types[1331]
#define SWIGTYPE_p_FIX__Spread swig_types[1332]
#define SWIGTYPE_p_FIX__SpreadToBenchmark swig_types[1333]
#define SWIGTYPE_p_FIX__StandInstDbID swig_types[1334]
#define SWIGTYPE_p_FIX__StandInstDbName swig_types[1335]
#define SWIGTYPE_p_FIX__StandInstDbType swig_types[1336]
#define SWIGTYPE_p_FIX__StartCash swig_types[1337]
#define SWIGTYPE_p_FIX__StartDate swig_types[1338]
#define SWIGTYPE_p_FIX__StartMaturityMonthYear swig_types[1339]
#define SWIGTYPE_p_FIX__StartStrikePxRange swig_types[1340]
#define SWIGTYPE_p_FIX__StartTickPriceRange swig_types[1341]
#define SWIGTYPE_p_FIX__StateOrProvinceOfIssue swig_types[1342]
#define SWIGTYPE_p_FIX__StatsType swig_types[1343]
#define SWIGTYPE_p_FIX__StatusText swig_types[1344]
#define SWIGTYPE_p_FIX__StatusValue swig_types[1345]
#define SWIGTYPE_p_FIX__StipulationType swig_types[1346]
#define SWIGTYPE_p_FIX__StipulationValue swig_types[1347]
#define SWIGTYPE_p_FIX__StopPx swig_types[1348]
#define SWIGTYPE_p_FIX__StrategyParameterName swig_types[1349]
#define SWIGTYPE_p_FIX__StrategyParameterType swig_types[1350]
#define SWIGTYPE_p_FIX__StrategyParameterValue swig_types[1351]
#define SWIGTYPE_p_FIX__StreamAsgnAckType swig_types[1352]
#define SWIGTYPE_p_FIX__StreamAsgnRejReason swig_types[1353]
#define SWIGTYPE_p_FIX__StreamAsgnReqID swig_types[1354]
#define SWIGTYPE_p_FIX__StreamAsgnReqType swig_types[1355]
#define SWIGTYPE_p_FIX__StreamAsgnRptID swig_types[1356]
#define SWIGTYPE_p_FIX__StreamAsgnType swig_types[1357]
#define SWIGTYPE_p_FIX__StrikeCurrency swig_types[1358]
#define SWIGTYPE_p_FIX__StrikeExerciseStyle swig_types[1359]
#define SWIGTYPE_p_FIX__StrikeIncrement swig_types[1360]
#define SWIGTYPE_p_FIX__StrikeMultiplier swig_types[1361]
#define SWIGTYPE_p_FIX__StrikePrice swig_types[1362]
#define SWIGTYPE_p_FIX__StrikePriceBoundaryMethod swig_types[1363]
#define SWIGTYPE_p_FIX__StrikePriceBoundaryPrecision swig_types[1364]
#define SWIGTYPE_p_FIX__StrikePriceDeterminationMethod swig_types[1365]
#define SWIGTYPE_p_FIX__StrikeRuleID swig_types[1366]
#define SWIGTYPE_p_FIX__StrikeTime swig_types[1367]
#define SWIGTYPE_p_FIX__StrikeValue swig_types[1368]
#define SWIGTYPE_p_FIX__StringField swig_types[1369]
#define SWIGTYPE_p_FIX__Subject swig_types[1370]
#define SWIGTYPE_p_FIX__SubscriptionRequestType swig_types[1371]
#define SWIGTYPE_p_FIX__SwapPoints swig_types[1372]
#define SWIGTYPE_p_FIX__Symbol swig_types[1373]
#define SWIGTYPE_p_FIX__SymbolSfx swig_types[1374]
#define SWIGTYPE_p_FIX__SynchronizedApplication swig_types[1375]
#define SWIGTYPE_p_FIX__TYPE__Type swig_types[1376]
#define SWIGTYPE_p_FIX__TZTIMEONLY swig_types[1377]
#define SWIGTYPE_p_FIX__TZTIMESTAMP swig_types[1378]
#define SWIGTYPE_p_FIX__TZTransactTime swig_types[1379]
#define SWIGTYPE_p_FIX__TagNotDefinedForMessage swig_types[1380]
#define SWIGTYPE_p_FIX__TagOutOfOrder swig_types[1381]
#define SWIGTYPE_p_FIX__TargetCompID swig_types[1382]
#define SWIGTYPE_p_FIX__TargetLocationID swig_types[1383]
#define SWIGTYPE_p_FIX__TargetPartyID swig_types[1384]
#define SWIGTYPE_p_FIX__TargetPartyIDSource swig_types[1385]
#define SWIGTYPE_p_FIX__TargetPartyRole swig_types[1386]
#define SWIGTYPE_p_FIX__TargetStrategy swig_types[1387]
#define SWIGTYPE_p_FIX__TargetStrategyParameters swig_types[1388]
#define SWIGTYPE_p_FIX__TargetStrategyPerformance swig_types[1389]
#define SWIGTYPE_p_FIX__TargetSubID swig_types[1390]
#define SWIGTYPE_p_FIX__TaxAdvantageType swig_types[1391]
#define SWIGTYPE_p_FIX__TerminationType swig_types[1392]
#define SWIGTYPE_p_FIX__TestMessageIndicator swig_types[1393]
#define SWIGTYPE_p_FIX__TestReqID swig_types[1394]
#define SWIGTYPE_p_FIX__Text swig_types[1395]
#define SWIGTYPE_p_FIX__ThresholdAmount swig_types[1396]
#define SWIGTYPE_p_FIX__TickDirection swig_types[1397]
#define SWIGTYPE_p_FIX__TickIncrement swig_types[1398]
#define SWIGTYPE_p_FIX__TickRuleType swig_types[1399]
#define SWIGTYPE_p_FIX__TierCode swig_types[1400]
#define SWIGTYPE_p_FIX__TimeBracket swig_types[1401]
#define SWIGTYPE_p_FIX__TimeInForce swig_types[1402]
#define SWIGTYPE_p_FIX__TimeToExpiration swig_types[1403]
#define SWIGTYPE_p_FIX__TimeUnit swig_types[1404]
#define SWIGTYPE_p_FIX__TotNoAccQuotes swig_types[1405]
#define SWIGTYPE_p_FIX__TotNoAllocs swig_types[1406]
#define SWIGTYPE_p_FIX__TotNoCxldQuotes swig_types[1407]
#define SWIGTYPE_p_FIX__TotNoFills swig_types[1408]
#define SWIGTYPE_p_FIX__TotNoOrders swig_types[1409]
#define SWIGTYPE_p_FIX__TotNoQuoteEntries swig_types[1410]
#define SWIGTYPE_p_FIX__TotNoRejQuotes swig_types[1411]
#define SWIGTYPE_p_FIX__TotNoRelatedSym swig_types[1412]
#define SWIGTYPE_p_FIX__TotNoSecurityTypes swig_types[1413]
#define SWIGTYPE_p_FIX__TotNoStrikes swig_types[1414]
#define SWIGTYPE_p_FIX__TotNumAssignmentReports swig_types[1415]
#define SWIGTYPE_p_FIX__TotNumReports swig_types[1416]
#define SWIGTYPE_p_FIX__TotNumTradeReports swig_types[1417]
#define SWIGTYPE_p_FIX__TotQuoteEntries swig_types[1418]
#define SWIGTYPE_p_FIX__TotalAccruedInterestAmt swig_types[1419]
#define SWIGTYPE_p_FIX__TotalAffectedOrders swig_types[1420]
#define SWIGTYPE_p_FIX__TotalNetValue swig_types[1421]
#define SWIGTYPE_p_FIX__TotalNumPosReports swig_types[1422]
#define SWIGTYPE_p_FIX__TotalNumSecurities swig_types[1423]
#define SWIGTYPE_p_FIX__TotalNumSecurityTypes swig_types[1424]
#define SWIGTYPE_p_FIX__TotalTakedown swig_types[1425]
#define SWIGTYPE_p_FIX__TotalVolumeTraded swig_types[1426]
#define SWIGTYPE_p_FIX__TotalVolumeTradedDate swig_types[1427]
#define SWIGTYPE_p_FIX__TotalVolumeTradedTime swig_types[1428]
#define SWIGTYPE_p_FIX__TradSesCloseTime swig_types[1429]
#define SWIGTYPE_p_FIX__TradSesEndTime swig_types[1430]
#define SWIGTYPE_p_FIX__TradSesEvent swig_types[1431]
#define SWIGTYPE_p_FIX__TradSesMethod swig_types[1432]
#define SWIGTYPE_p_FIX__TradSesMode swig_types[1433]
#define SWIGTYPE_p_FIX__TradSesOpenTime swig_types[1434]
#define SWIGTYPE_p_FIX__TradSesPreCloseTime swig_types[1435]
#define SWIGTYPE_p_FIX__TradSesReqID swig_types[1436]
#define SWIGTYPE_p_FIX__TradSesStartTime swig_types[1437]
#define SWIGTYPE_p_FIX__TradSesStatus swig_types[1438]
#define SWIGTYPE_p_FIX__TradSesStatusRejReason swig_types[1439]
#define SWIGTYPE_p_FIX__TradSesUpdateAction swig_types[1440]
#define SWIGTYPE_p_FIX__TradeAllocIndicator swig_types[1441]
#define SWIGTYPE_p_FIX__TradeCondition swig_types[1442]
#define SWIGTYPE_p_FIX__TradeDate swig_types[1443]
#define SWIGTYPE_p_FIX__TradeHandlingInstr swig_types[1444]
#define SWIGTYPE_p_FIX__TradeID swig_types[1445]
#define SWIGTYPE_p_FIX__TradeInputDevice swig_types[1446]
#define SWIGTYPE_p_FIX__TradeInputSource swig_types[1447]
#define SWIGTYPE_p_FIX__TradeLegRefID swig_types[1448]
#define SWIGTYPE_p_FIX__TradeLinkID swig_types[1449]
#define SWIGTYPE_p_FIX__TradeOriginationDate swig_types[1450]
#define SWIGTYPE_p_FIX__TradePublishIndicator swig_types[1451]
#define SWIGTYPE_p_FIX__TradeReportID swig_types[1452]
#define SWIGTYPE_p_FIX__TradeReportRefID swig_types[1453]
#define SWIGTYPE_p_FIX__TradeReportRejectReason swig_types[1454]
#define SWIGTYPE_p_FIX__TradeReportTransType swig_types[1455]
#define SWIGTYPE_p_FIX__TradeReportType swig_types[1456]
#define SWIGTYPE_p_FIX__TradeRequestID swig_types[1457]
#define SWIGTYPE_p_FIX__TradeRequestResult swig_types[1458]
#define SWIGTYPE_p_FIX__TradeRequestStatus swig_types[1459]
#define SWIGTYPE_p_FIX__TradeRequestType swig_types[1460]
#define SWIGTYPE_p_FIX__TradeType swig_types[1461]
#define SWIGTYPE_p_FIX__TradeVolume swig_types[1462]
#define SWIGTYPE_p_FIX__TradedFlatSwitch swig_types[1463]
#define SWIGTYPE_p_FIX__TradingCurrency swig_types[1464]
#define SWIGTYPE_p_FIX__TradingReferencePrice swig_types[1465]
#define SWIGTYPE_p_FIX__TradingSessionDesc swig_types[1466]
#define SWIGTYPE_p_FIX__TradingSessionID swig_types[1467]
#define SWIGTYPE_p_FIX__TradingSessionSubID swig_types[1468]
#define SWIGTYPE_p_FIX__Trailer swig_types[1469]
#define SWIGTYPE_p_FIX__TransBkdTime swig_types[1470]
#define SWIGTYPE_p_FIX__TransactTime swig_types[1471]
#define SWIGTYPE_p_FIX__TransferReason swig_types[1472]
#define SWIGTYPE_p_FIX__TrdMatchID swig_types[1473]
#define SWIGTYPE_p_FIX__TrdRegTimestamp swig_types[1474]
#define SWIGTYPE_p_FIX__TrdRegTimestampOrigin swig_types[1475]
#define SWIGTYPE_p_FIX__TrdRegTimestampType swig_types[1476]
#define SWIGTYPE_p_FIX__TrdRepIndicator swig_types[1477]
#define SWIGTYPE_p_FIX__TrdRepPartyRole swig_types[1478]
#define SWIGTYPE_p_FIX__TrdRptStatus swig_types[1479]
#define SWIGTYPE_p_FIX__TrdSubType swig_types[1480]
#define SWIGTYPE_p_FIX__TrdType swig_types[1481]
#define SWIGTYPE_p_FIX__TriggerAction swig_types[1482]
#define SWIGTYPE_p_FIX__TriggerNewPrice swig_types[1483]
#define SWIGTYPE_p_FIX__TriggerNewQty swig_types[1484]
#define SWIGTYPE_p_FIX__TriggerOrderType swig_types[1485]
#define SWIGTYPE_p_FIX__TriggerPrice swig_types[1486]
#define SWIGTYPE_p_FIX__TriggerPriceDirection swig_types[1487]
#define SWIGTYPE_p_FIX__TriggerPriceType swig_types[1488]
#define SWIGTYPE_p_FIX__TriggerPriceTypeScope swig_types[1489]
#define SWIGTYPE_p_FIX__TriggerSecurityDesc swig_types[1490]
#define SWIGTYPE_p_FIX__TriggerSecurityID swig_types[1491]
#define SWIGTYPE_p_FIX__TriggerSecurityIDSource swig_types[1492]
#define SWIGTYPE_p_FIX__TriggerSymbol swig_types[1493]
#define SWIGTYPE_p_FIX__TriggerTradingSessionID swig_types[1494]
#define SWIGTYPE_p_FIX__TriggerTradingSessionSubID swig_types[1495]
#define SWIGTYPE_p_FIX__TriggerType swig_types[1496]
#define SWIGTYPE_p_FIX__URLLink swig_types[1497]
#define SWIGTYPE_p_FIX__UTCDATE swig_types[1498]
#define SWIGTYPE_p_FIX__UTCDATEONLY swig_types[1499]
#define SWIGTYPE_p_FIX__UTCTIMEONLY swig_types[1500]
#define SWIGTYPE_p_FIX__UTCTIMESTAMP swig_types[1501]
#define SWIGTYPE_p_FIX__UnderlyingAdjustedQuantity swig_types[1502]
#define SWIGTYPE_p_FIX__UnderlyingAllocationPercent swig_types[1503]
#define SWIGTYPE_p_FIX__UnderlyingAttachmentPoint swig_types[1504]
#define SWIGTYPE_p_FIX__UnderlyingCFICode swig_types[1505]
#define SWIGTYPE_p_FIX__UnderlyingCPProgram swig_types[1506]
#define SWIGTYPE_p_FIX__UnderlyingCPRegType swig_types[1507]
#define SWIGTYPE_p_FIX__UnderlyingCapValue swig_types[1508]
#define SWIGTYPE_p_FIX__UnderlyingCashAmount swig_types[1509]
#define SWIGTYPE_p_FIX__UnderlyingCashType swig_types[1510]
#define SWIGTYPE_p_FIX__UnderlyingCollectAmount swig_types[1511]
#define SWIGTYPE_p_FIX__UnderlyingContractMultiplier swig_types[1512]
#define SWIGTYPE_p_FIX__UnderlyingContractMultiplierUnit swig_types[1513]
#define SWIGTYPE_p_FIX__UnderlyingCountryOfIssue swig_types[1514]
#define SWIGTYPE_p_FIX__UnderlyingCouponPaymentDate swig_types[1515]
#define SWIGTYPE_p_FIX__UnderlyingCouponRate swig_types[1516]
#define SWIGTYPE_p_FIX__UnderlyingCreditRating swig_types[1517]
#define SWIGTYPE_p_FIX__UnderlyingCurrency swig_types[1518]
#define SWIGTYPE_p_FIX__UnderlyingCurrentValue swig_types[1519]
#define SWIGTYPE_p_FIX__UnderlyingDeliveryAmount swig_types[1520]
#define SWIGTYPE_p_FIX__UnderlyingDetachmentPoint swig_types[1521]
#define SWIGTYPE_p_FIX__UnderlyingDirtyPrice swig_types[1522]
#define SWIGTYPE_p_FIX__UnderlyingEndPrice swig_types[1523]
#define SWIGTYPE_p_FIX__UnderlyingEndValue swig_types[1524]
#define SWIGTYPE_p_FIX__UnderlyingExerciseStyle swig_types[1525]
#define SWIGTYPE_p_FIX__UnderlyingFXRate swig_types[1526]
#define SWIGTYPE_p_FIX__UnderlyingFXRateCalc swig_types[1527]
#define SWIGTYPE_p_FIX__UnderlyingFactor swig_types[1528]
#define SWIGTYPE_p_FIX__UnderlyingFlowScheduleType swig_types[1529]
#define SWIGTYPE_p_FIX__UnderlyingIDSource swig_types[1530]
#define SWIGTYPE_p_FIX__UnderlyingInstrRegistry swig_types[1531]
#define SWIGTYPE_p_FIX__UnderlyingInstrumentPartyID swig_types[1532]
#define SWIGTYPE_p_FIX__UnderlyingInstrumentPartyIDSource swig_types[1533]
#define SWIGTYPE_p_FIX__UnderlyingInstrumentPartyRole swig_types[1534]
#define SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubID swig_types[1535]
#define SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubIDType swig_types[1536]
#define SWIGTYPE_p_FIX__UnderlyingIssueDate swig_types[1537]
#define SWIGTYPE_p_FIX__UnderlyingIssuer swig_types[1538]
#define SWIGTYPE_p_FIX__UnderlyingLastPx swig_types[1539]
#define SWIGTYPE_p_FIX__UnderlyingLastQty swig_types[1540]
#define SWIGTYPE_p_FIX__UnderlyingLegCFICode swig_types[1541]
#define SWIGTYPE_p_FIX__UnderlyingLegMaturityDate swig_types[1542]
#define SWIGTYPE_p_FIX__UnderlyingLegMaturityMonthYear swig_types[1543]
#define SWIGTYPE_p_FIX__UnderlyingLegMaturityTime swig_types[1544]
#define SWIGTYPE_p_FIX__UnderlyingLegOptAttribute swig_types[1545]
#define SWIGTYPE_p_FIX__UnderlyingLegPutOrCall swig_types[1546]
#define SWIGTYPE_p_FIX__UnderlyingLegSecurityAltID swig_types[1547]
#define SWIGTYPE_p_FIX__UnderlyingLegSecurityAltIDSource swig_types[1548]
#define SWIGTYPE_p_FIX__UnderlyingLegSecurityDesc swig_types[1549]
#define SWIGTYPE_p_FIX__UnderlyingLegSecurityExchange swig_types[1550]
#define SWIGTYPE_p_FIX__UnderlyingLegSecurityID swig_types[1551]
#define SWIGTYPE_p_FIX__UnderlyingLegSecurityIDSource swig_types[1552]
#define SWIGTYPE_p_FIX__UnderlyingLegSecuritySubType swig_types[1553]
#define SWIGTYPE_p_FIX__UnderlyingLegSecurityType swig_types[1554]
#define SWIGTYPE_p_FIX__UnderlyingLegStrikePrice swig_types[1555]
#define SWIGTYPE_p_FIX__UnderlyingLegSymbol swig_types[1556]
#define SWIGTYPE_p_FIX__UnderlyingLegSymbolSfx swig_types[1557]
#define SWIGTYPE_p_FIX__UnderlyingLocaleOfIssue swig_types[1558]
#define SWIGTYPE_p_FIX__UnderlyingMaturityDate swig_types[1559]
#define SWIGTYPE_p_FIX__UnderlyingMaturityDay swig_types[1560]
#define SWIGTYPE_p_FIX__UnderlyingMaturityMonthYear swig_types[1561]
#define SWIGTYPE_p_FIX__UnderlyingMaturityTime swig_types[1562]
#define SWIGTYPE_p_FIX__UnderlyingNotionalPercentageOutstanding swig_types[1563]
#define SWIGTYPE_p_FIX__UnderlyingOptAttribute swig_types[1564]
#define SWIGTYPE_p_FIX__UnderlyingOriginalNotionalPercentageOutstanding swig_types[1565]
#define SWIGTYPE_p_FIX__UnderlyingPayAmount swig_types[1566]
#define SWIGTYPE_p_FIX__UnderlyingPriceDeterminationMethod swig_types[1567]
#define SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasure swig_types[1568]
#define SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasureQty swig_types[1569]
#define SWIGTYPE_p_FIX__UnderlyingProduct swig_types[1570]
#define SWIGTYPE_p_FIX__UnderlyingPutOrCall swig_types[1571]
#define SWIGTYPE_p_FIX__UnderlyingPx swig_types[1572]
#define SWIGTYPE_p_FIX__UnderlyingQty swig_types[1573]
#define SWIGTYPE_p_FIX__UnderlyingRedemptionDate swig_types[1574]
#define SWIGTYPE_p_FIX__UnderlyingRepoCollateralSecurityType swig_types[1575]
#define SWIGTYPE_p_FIX__UnderlyingRepurchaseRate swig_types[1576]
#define SWIGTYPE_p_FIX__UnderlyingRepurchaseTerm swig_types[1577]
#define SWIGTYPE_p_FIX__UnderlyingRestructuringType swig_types[1578]
#define SWIGTYPE_p_FIX__UnderlyingSecurityAltID swig_types[1579]
#define SWIGTYPE_p_FIX__UnderlyingSecurityAltIDSource swig_types[1580]
#define SWIGTYPE_p_FIX__UnderlyingSecurityDesc swig_types[1581]
#define SWIGTYPE_p_FIX__UnderlyingSecurityExchange swig_types[1582]
#define SWIGTYPE_p_FIX__UnderlyingSecurityID swig_types[1583]
#define SWIGTYPE_p_FIX__UnderlyingSecurityIDSource swig_types[1584]
#define SWIGTYPE_p_FIX__UnderlyingSecuritySubType swig_types[1585]
#define SWIGTYPE_p_FIX__UnderlyingSecurityType swig_types[1586]
#define SWIGTYPE_p_FIX__UnderlyingSeniority swig_types[1587]
#define SWIGTYPE_p_FIX__UnderlyingSettlMethod swig_types[1588]
#define SWIGTYPE_p_FIX__UnderlyingSettlPrice swig_types[1589]
#define SWIGTYPE_p_FIX__UnderlyingSettlPriceType swig_types[1590]
#define SWIGTYPE_p_FIX__UnderlyingSettlementDate swig_types[1591]
#define SWIGTYPE_p_FIX__UnderlyingSettlementStatus swig_types[1592]
#define SWIGTYPE_p_FIX__UnderlyingSettlementType swig_types[1593]
#define SWIGTYPE_p_FIX__UnderlyingStartValue swig_types[1594]
#define SWIGTYPE_p_FIX__UnderlyingStateOrProvinceOfIssue swig_types[1595]
#define SWIGTYPE_p_FIX__UnderlyingStipType swig_types[1596]
#define SWIGTYPE_p_FIX__UnderlyingStipValue swig_types[1597]
#define SWIGTYPE_p_FIX__UnderlyingStrikeCurrency swig_types[1598]
#define SWIGTYPE_p_FIX__UnderlyingStrikePrice swig_types[1599]
#define SWIGTYPE_p_FIX__UnderlyingSymbol swig_types[1600]
#define SWIGTYPE_p_FIX__UnderlyingSymbolSfx swig_types[1601]
#define SWIGTYPE_p_FIX__UnderlyingTimeUnit swig_types[1602]
#define SWIGTYPE_p_FIX__UnderlyingTradingSessionID swig_types[1603]
#define SWIGTYPE_p_FIX__UnderlyingTradingSessionSubID swig_types[1604]
#define SWIGTYPE_p_FIX__UnderlyingUnitOfMeasure swig_types[1605]
#define SWIGTYPE_p_FIX__UnderlyingUnitOfMeasureQty swig_types[1606]
#define SWIGTYPE_p_FIX__UndlyInstrumentPartyID swig_types[1607]
#define SWIGTYPE_p_FIX__UndlyInstrumentPartyIDSource swig_types[1608]
#define SWIGTYPE_p_FIX__UndlyInstrumentPartyRole swig_types[1609]
#define SWIGTYPE_p_FIX__UndlyInstrumentPartySubID swig_types[1610]
#define SWIGTYPE_p_FIX__UndlyInstrumentPartySubIDType swig_types[1611]
#define SWIGTYPE_p_FIX__UnitOfMeasure swig_types[1612]
#define SWIGTYPE_p_FIX__UnitOfMeasureQty swig_types[1613]
#define SWIGTYPE_p_FIX__UnsolicitedIndicator swig_types[1614]
#define SWIGTYPE_p_FIX__UnsupportedMessageType swig_types[1615]
#define SWIGTYPE_p_FIX__UnsupportedVersion swig_types[1616]
#define SWIGTYPE_p_FIX__Urgency swig_types[1617]
#define SWIGTYPE_p_FIX__UserRequestID swig_types[1618]
#define SWIGTYPE_p_FIX__UserRequestType swig_types[1619]
#define SWIGTYPE_p_FIX__UserStatus swig_types[1620]
#define SWIGTYPE_p_FIX__UserStatusText swig_types[1621]
#define SWIGTYPE_p_FIX__Username swig_types[1622]
#define SWIGTYPE_p_FIX__UtcDateField swig_types[1623]
#define SWIGTYPE_p_FIX__UtcTimeOnlyField swig_types[1624]
#define SWIGTYPE_p_FIX__UtcTimeStampField swig_types[1625]
#define SWIGTYPE_p_FIX__ValidUntilTime swig_types[1626]
#define SWIGTYPE_p_FIX__ValuationMethod swig_types[1627]
#define SWIGTYPE_p_FIX__ValueOfFutures swig_types[1628]
#define SWIGTYPE_p_FIX__VenueType swig_types[1629]
#define SWIGTYPE_p_FIX__Volatility swig_types[1630]
#define SWIGTYPE_p_FIX__WaveNo swig_types[1631]
#define SWIGTYPE_p_FIX__WorkingIndicator swig_types[1632]
#define SWIGTYPE_p_FIX__WtAverageLiquidity swig_types[1633]
#define SWIGTYPE_p_FIX__XMLDATA swig_types[1634]
#define SWIGTYPE_p_FIX__XmlData swig_types[1635]
#define SWIGTYPE_p_FIX__XmlDataLen swig_types[1636]
#define SWIGTYPE_p_FIX__Yield swig_types[1637]
#define SWIGTYPE_p_FIX__YieldCalcDate swig_types[1638]
#define SWIGTYPE_p_FIX__YieldRedemptionDate swig_types[1639]
#define SWIGTYPE_p_FIX__YieldRedemptionPrice swig_types[1640]
#define SWIGTYPE_p_FIX__YieldRedemptionPriceType swig_types[1641]
#define SWIGTYPE_p_FIX__YieldType swig_types[1642]
#define SWIGTYPE_p_Fields swig_types[1643]
#define SWIGTYPE_p_Group swig_types[1644]
#define SWIGTYPE_p_Groups swig_types[1645]
#define SWIGTYPE_p_IntArray swig_types[1646]
#define SWIGTYPE_p_IntField swig_types[1647]
#define SWIGTYPE_p_Log swig_types[1648]
#define SWIGTYPE_p_LogFactory swig_types[1649]
#define SWIGTYPE_p_MessageStore swig_types[1650]
#define SWIGTYPE_p_MessageStoreFactory swig_types[1651]
#define SWIGTYPE_p_MsgType swig_types[1652]
#define SWIGTYPE_p_Mutex swig_types[1653]
#define SWIGTYPE_p_Responder swig_types[1654]
#define SWIGTYPE_p_SessionID swig_types[1655]
#define SWIGTYPE_p_StringField swig_types[1656]
#define SWIGTYPE_p_TimeRange swig_types[1657]
#define SWIGTYPE_p_UtcDate swig_types[1658]
#define SWIGTYPE_p_UtcDateField swig_types[1659]
#define SWIGTYPE_p_UtcTimeOnly swig_types[1660]
#define SWIGTYPE_p_UtcTimeStamp swig_types[1661]
#define SWIGTYPE_p_bool swig_types[1662]
#define SWIGTYPE_p_char swig_types[1663]
#define SWIGTYPE_p_const_iterator swig_types[1664]
#define SWIGTYPE_p_g_const_iterator swig_types[1665]
#define SWIGTYPE_p_g_iterator swig_types[1666]
#define SWIGTYPE_p_int swig_types[1667]
#define SWIGTYPE_p_iterator swig_types[1668]
#define SWIGTYPE_p_message_order swig_types[1669]
#define SWIGTYPE_p_p_FIX__DataDictionary swig_types[1670]
#define SWIGTYPE_p_std__istream swig_types[1671]
#define SWIGTYPE_p_std__ostream swig_types[1672]
#define SWIGTYPE_p_std__setT_FIX__SessionID_t swig_types[1673]
#define SWIGTYPE_p_std__string swig_types[1674]
#define SWIGTYPE_p_std__string__size_type swig_types[1675]
#define SWIGTYPE_p_std__vectorT_std__string_t swig_types[1676]
static swig_type_info *swig_types[1678];
static swig_module_info swig_module = {swig_types, 1677, 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):= _quickfix.so
  ------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_init    PyInit__quickfix

#else
#  define SWIG_init    init_quickfix

#endif
#define SWIG_name    "_quickfix"

#define SWIGVERSION 0x020004 
#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)
    {
      Py_XINCREF(_obj);      
    }
    
    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    {
      if (initial_ref) {
        Py_XINCREF(_obj);
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
      Py_XINCREF(item._obj);
      Py_XDECREF(_obj);
      _obj = item._obj;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
      Py_XDECREF(_obj);
    }
    
    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 <string>


typedef int IntArray;


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;
  } else if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } 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 (PyInt_Check(obj)) {
    long v = PyInt_AsLong(obj);
    if (v >= 0) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      return SWIG_OverflowError;
    }
  } else if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#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;
}

SWIGINTERN IntArray *new_IntArray(size_t nelements){
    return (new int[nelements]);
  }
SWIGINTERN void delete_IntArray(IntArray *self){
    delete[] self;
  }
SWIGINTERN int IntArray___getitem__(IntArray *self,size_t index){
    return self[index];
  }

  #define SWIG_From_long   PyInt_FromLong 


SWIGINTERNINLINE PyObject *
SWIG_From_int  (int value)
{    
  return SWIG_From_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_long (PyObject *obj, long* val)
{
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#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;
}


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;
}

SWIGINTERN void IntArray___setitem__(IntArray *self,size_t index,int value){
    self[index] = value;
  }
SWIGINTERN int *IntArray_cast(IntArray *self){
    return self;
  }
SWIGINTERN IntArray *IntArray_frompointer(int *t){
    return static_cast< IntArray * >(t);
  }

#include <config.h>
#include "../C++/Exceptions.h"
#include "../C++/Field.h"
#include "../C++/Message.h"
#include "../C++/Group.h"
#include "../C++/Fields.h"
#include "../C++/Values.h"
#include "../C++/SessionID.h"
#include "../C++/Dictionary.h"
#include "../C++/SessionSettings.h"
#include "../C++/Session.h"
#include "../C++/SessionID.h"
#include "../C++/Log.h"
#include "../C++/FileLog.h"
#include "../C++/MessageStore.h"
#include "../C++/FileStore.h"
#include "../C++/Application.h"
#include "../C++/Initiator.h"
#include "../C++/SocketInitiator.h"
#include "../C++/Acceptor.h"
#include "../C++/SocketAcceptor.h"
#include "../C++/DataDictionary.h"
typedef FIX::UtcTimeStamp UtcTimeStamp;
typedef FIX::UtcDate UtcDate;
typedef FIX::UtcTimeOnly UtcTimeOnly;
typedef FIX::message_order message_order;
typedef FIX::Group Group;
typedef FIX::DataDictionary DataDictionary;
typedef FIX::DataDictionaryProvider DataDictionaryProvider;
typedef FIX::MsgType MsgType;
typedef FIX::BeginString BeginString;
typedef FIX::ApplVerID ApplVerID;
typedef FIX::SessionID SessionID;
typedef FIX::Session Session;
typedef FIX::Application Application;
typedef FIX::DateTime DateTime;
typedef FIX::TimeRange TimeRange;
typedef FIX::Responder Responder;
typedef FIX::Log Log;
typedef FIX::LogFactory LogFactory;
typedef FIX::MessageStore MessageStore;
typedef FIX::MessageStoreFactory MessageStoreFactory;
typedef FIX::Mutex Mutex;
typedef FIX::DOMDocumentPtr DOMDocumentPtr;


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;
}


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 {
    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_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;
}


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
      return PyUnicode_FromStringAndSize(carray, static_cast< int >(size));
#else
      return PyString_FromStringAndSize(carray, static_cast< int >(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


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

SWIGINTERN std::string FIX_Exception___str__(FIX::Exception *self){
    return self->what();
  }

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

SWIGINTERN std::string FIX_FieldBase___str__(FIX::FieldBase *self){
    return self->getFixString();
  }




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)) {
    if ((csize == size + 1) && cptr && !(cptr[csize-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;
}


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


  #define SWIG_From_double   PyFloat_FromDouble 


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


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 std::string FIX_Message___str__(FIX::Message *self){
    return self->toString();
  }

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

SWIGINTERN std::string FIX_SessionID___str__(FIX::SessionID *self){
    return self->toString();
  }


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

#include "QuickfixPython.h"

SwigDirector_Application::SwigDirector_Application(PyObject *self): FIX::Application(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((FIX::Application *)this, this); 
}




SwigDirector_Application::~SwigDirector_Application() {
}

void SwigDirector_Application::onCreate(FIX::SessionID const &arg0) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__SessionID,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Application.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 0;
    const char * const swig_method_name = "onCreate";
    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 *)"onCreate", (char *)"(O)" ,(PyObject *)obj0);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          PyObject *ptype, *pvalue, *ptraceback;
          PyErr_Fetch( &ptype, &pvalue, &ptraceback );
          PyErr_Restore( ptype, pvalue, ptraceback );
          PyErr_Print();
          Py_Exit(1);
        }
        
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


void SwigDirector_Application::onLogon(FIX::SessionID const &arg0) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__SessionID,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Application.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 1;
    const char * const swig_method_name = "onLogon";
    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 *)"onLogon", (char *)"(O)" ,(PyObject *)obj0);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          PyObject *ptype, *pvalue, *ptraceback;
          PyErr_Fetch( &ptype, &pvalue, &ptraceback );
          PyErr_Restore( ptype, pvalue, ptraceback );
          PyErr_Print();
          Py_Exit(1);
        }
        
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


void SwigDirector_Application::onLogout(FIX::SessionID const &arg0) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__SessionID,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Application.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 2;
    const char * const swig_method_name = "onLogout";
    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 *)"onLogout", (char *)"(O)" ,(PyObject *)obj0);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          PyObject *ptype, *pvalue, *ptraceback;
          PyErr_Fetch( &ptype, &pvalue, &ptraceback );
          PyErr_Restore( ptype, pvalue, ptraceback );
          PyErr_Print();
          Py_Exit(1);
        }
        
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


void SwigDirector_Application::toAdmin(FIX::Message &arg0, FIX::SessionID const &arg1) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__Message,  0 );
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_FIX__SessionID,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Application.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 3;
    const char * const swig_method_name = "toAdmin";
    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 *)"toAdmin", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          PyObject *ptype, *pvalue, *ptraceback;
          PyErr_Fetch( &ptype, &pvalue, &ptraceback );
          PyErr_Restore( ptype, pvalue, ptraceback );
          PyErr_Print();
          Py_Exit(1);
        }
        
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


void SwigDirector_Application::toApp(FIX::Message &arg0, FIX::SessionID const &arg1) throw(FIX::DoNotSend) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__Message,  0 );
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_FIX__SessionID,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Application.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 4;
    const char * const swig_method_name = "toApp";
    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 *)"toApp", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          PyObject *ptype, *pvalue, *ptraceback;
          PyErr_Fetch( &ptype, &pvalue, &ptraceback );
          void *result;
          
          try {
            if( SWIG_ConvertPtr(pvalue, &result, SWIGTYPE_p_FIX__DoNotSend, 0 ) != -1 ) {
              throw *((FIX::DoNotSend*)result);
            } else {
              PyErr_Restore( ptype, pvalue, ptraceback );
              PyErr_Print();
              Py_Exit(1);
            }
          } catch( std::exception& e ) {
            std::cout << e.what() << std::endl;
            Py_XDECREF( ptype );
            Py_XDECREF( pvalue );
            Py_XDECREF( ptraceback );
            throw;
          } catch( ... ) {
            std::cout << "Fatal exception" << std::endl;
            Py_XDECREF( ptype );
            Py_XDECREF( pvalue );
            Py_XDECREF( ptraceback );
            throw;
          }
        }
        
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


void SwigDirector_Application::fromAdmin(FIX::Message const &arg0, FIX::SessionID const &arg1) throw(FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::RejectLogon) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__Message,  0 );
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_FIX__SessionID,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Application.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 5;
    const char * const swig_method_name = "fromAdmin";
    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 *)"fromAdmin", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          PyObject *ptype, *pvalue, *ptraceback;
          PyErr_Fetch( &ptype, &pvalue, &ptraceback );
          void *result;
          
          try {
            if( SWIG_ConvertPtr(pvalue, &result, SWIGTYPE_p_FIX__FieldNotFound, 0 ) != -1 ) {
              throw *((FIX::FieldNotFound*)result);
            } else if( SWIG_ConvertPtr(pvalue, &result, SWIGTYPE_p_FIX__IncorrectDataFormat, 0 ) != -1 ) {
              throw *((FIX::IncorrectDataFormat*)result);
            } else if( SWIG_ConvertPtr(pvalue, &result, SWIGTYPE_p_FIX__IncorrectTagValue, 0 ) != -1 ) {
              throw *((FIX::IncorrectTagValue*)result);
            } else if( SWIG_ConvertPtr(pvalue, &result, SWIGTYPE_p_FIX__RejectLogon, 0 ) != -1 ) {
              throw *((FIX::RejectLogon*)result);
            } else {
              PyErr_Restore( ptype, pvalue, ptraceback );
              PyErr_Print();
              Py_Exit(1);
            }
          } catch( std::exception& e ) {
            std::cout << e.what() << std::endl;
            Py_XDECREF( ptype );
            Py_XDECREF( pvalue );
            Py_XDECREF( ptraceback );
            throw;
          } catch( ... ) {
            std::cout << "Fatal exception" << std::endl;
            Py_XDECREF( ptype );
            Py_XDECREF( pvalue );
            Py_XDECREF( ptraceback );
            throw;
          }
        }
        
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


void SwigDirector_Application::fromApp(FIX::Message const &arg0, FIX::SessionID const &arg1) throw(FIX::FieldNotFound, FIX::IncorrectDataFormat, FIX::IncorrectTagValue, FIX::UnsupportedMessageType) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  {
    swig::SwigVar_PyObject obj0;
    obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_FIX__Message,  0 );
    swig::SwigVar_PyObject obj1;
    obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_FIX__SessionID,  0 );
    if (!swig_get_self()) {
      Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Application.__init__.");
    }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
    const size_t swig_method_index = 6;
    const char * const swig_method_name = "fromApp";
    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 *)"fromApp", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
    if (!result) {
      PyObject *error = PyErr_Occurred();
      {
        if( error != NULL ) {
          PyObject *ptype, *pvalue, *ptraceback;
          PyErr_Fetch( &ptype, &pvalue, &ptraceback );
          void *result;
          
          try {
            if( SWIG_ConvertPtr(pvalue, &result, SWIGTYPE_p_FIX__FieldNotFound, 0 ) != -1 ) {
              throw *((FIX::FieldNotFound*)result);
            } else if( SWIG_ConvertPtr(pvalue, &result, SWIGTYPE_p_FIX__IncorrectDataFormat, 0 ) != -1 ) {
              throw *((FIX::IncorrectDataFormat*)result);
            } else if( SWIG_ConvertPtr(pvalue, &result, SWIGTYPE_p_FIX__IncorrectTagValue, 0 ) != -1 ) {
              throw *((FIX::IncorrectTagValue*)result);
            } else if( SWIG_ConvertPtr(pvalue, &result, SWIGTYPE_p_FIX__UnsupportedMessageType, 0 ) != -1 ) {
              throw *((FIX::UnsupportedMessageType*)result);
            } else {
              PyErr_Restore( ptype, pvalue, ptraceback );
              PyErr_Print();
              Py_Exit(1);
            }
          } catch( std::exception& e ) {
            std::cout << e.what() << std::endl;
            Py_XDECREF( ptype );
            Py_XDECREF( pvalue );
            Py_XDECREF( ptraceback );
            throw;
          } catch( ... ) {
            std::cout << "Fatal exception" << std::endl;
            Py_XDECREF( ptype );
            Py_XDECREF( pvalue );
            Py_XDECREF( ptraceback );
            throw;
          }
        }
        
      }
    }
  }
  SWIG_PYTHON_THREAD_END_BLOCK;
}


#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_new_IntArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  IntArray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IntArray",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntArray" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (IntArray *)new_IntArray(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IntArray, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IntArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IntArray *arg1 = (IntArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IntArray",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_IntArray, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntArray" "', argument " "1"" of type '" "IntArray *""'"); 
  }
  arg1 = reinterpret_cast< IntArray * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete_IntArray(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IntArray *arg1 = (IntArray *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:IntArray___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_IntArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArray___getitem__" "', argument " "1"" of type '" "IntArray *""'"); 
  }
  arg1 = reinterpret_cast< IntArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntArray___getitem__" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)IntArray___getitem__(arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IntArray *arg1 = (IntArray *) 0 ;
  size_t arg2 ;
  int 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 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:IntArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_IntArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArray___setitem__" "', argument " "1"" of type '" "IntArray *""'"); 
  }
  arg1 = reinterpret_cast< IntArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntArray___setitem__" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntArray___setitem__" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    IntArray___setitem__(arg1,arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntArray_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  IntArray *arg1 = (IntArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:IntArray_cast",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_IntArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArray_cast" "', argument " "1"" of type '" "IntArray *""'"); 
  }
  arg1 = reinterpret_cast< IntArray * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int *)IntArray_cast(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntArray_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  IntArray *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:IntArray_frompointer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArray_frompointer" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (IntArray *)IntArray_frompointer(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IntArray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Exception(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::Exception *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Exception",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Exception" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Exception" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    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_Exception" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Exception" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Exception *)new FIX::Exception((std::string const &)*arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Exception, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Exception(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Exception *arg1 = (FIX::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Exception",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Exception, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Exception" "', argument " "1"" of type '" "FIX::Exception *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exception_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Exception *arg1 = (FIX::Exception *) 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:Exception_type_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Exception_type_set" "', argument " "1"" of type '" "FIX::Exception *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(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 '" "Exception_type_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Exception_type_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->type = *arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exception_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Exception *arg1 = (FIX::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Exception_type_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Exception_type_get" "', argument " "1"" of type '" "FIX::Exception *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) & ((arg1)->type);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exception_detail_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Exception *arg1 = (FIX::Exception *) 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:Exception_detail_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Exception_detail_set" "', argument " "1"" of type '" "FIX::Exception *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(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 '" "Exception_detail_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Exception_detail_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->detail = *arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exception_detail_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Exception *arg1 = (FIX::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Exception_detail_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Exception_detail_get" "', argument " "1"" of type '" "FIX::Exception *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) & ((arg1)->detail);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Exception___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Exception *arg1 = (FIX::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Exception___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Exception___str__" "', argument " "1"" of type '" "FIX::Exception *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Exception * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = FIX_Exception___str__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DataDictionaryNotFound__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::DataDictionaryNotFound *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_DataDictionaryNotFound",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataDictionaryNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataDictionaryNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    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_DataDictionaryNotFound" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataDictionaryNotFound" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DataDictionaryNotFound *)new FIX::DataDictionaryNotFound((std::string const &)*arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DataDictionaryNotFound, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionaryNotFound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::DataDictionaryNotFound *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DataDictionaryNotFound",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataDictionaryNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataDictionaryNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DataDictionaryNotFound *)new FIX::DataDictionaryNotFound((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DataDictionaryNotFound, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionaryNotFound(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_new_DataDictionaryNotFound__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_DataDictionaryNotFound__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DataDictionaryNotFound'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DataDictionaryNotFound::DataDictionaryNotFound(std::string const &,std::string const &)\n"
    "    FIX::DataDictionaryNotFound::DataDictionaryNotFound(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DataDictionaryNotFound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionaryNotFound *arg1 = (FIX::DataDictionaryNotFound *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DataDictionaryNotFound",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionaryNotFound, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataDictionaryNotFound" "', argument " "1"" of type '" "FIX::DataDictionaryNotFound *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionaryNotFound * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionaryNotFound_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionaryNotFound *arg1 = (FIX::DataDictionaryNotFound *) 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:DataDictionaryNotFound_version_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionaryNotFound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionaryNotFound_version_set" "', argument " "1"" of type '" "FIX::DataDictionaryNotFound *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionaryNotFound * >(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 '" "DataDictionaryNotFound_version_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionaryNotFound_version_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->version = *arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionaryNotFound_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionaryNotFound *arg1 = (FIX::DataDictionaryNotFound *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DataDictionaryNotFound_version_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionaryNotFound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionaryNotFound_version_get" "', argument " "1"" of type '" "FIX::DataDictionaryNotFound *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionaryNotFound * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) & ((arg1)->version);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FieldNotFound__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::FieldNotFound *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_FieldNotFound",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FieldNotFound" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(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_FieldNotFound" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FieldNotFound" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FieldNotFound *)new FIX::FieldNotFound(arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldNotFound, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldNotFound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FieldNotFound *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FieldNotFound",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FieldNotFound" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FieldNotFound *)new FIX::FieldNotFound(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldNotFound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldNotFound__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldNotFound *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FieldNotFound")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FieldNotFound *)new FIX::FieldNotFound();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldNotFound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldNotFound(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FieldNotFound__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_FieldNotFound__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_FieldNotFound__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FieldNotFound'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldNotFound::FieldNotFound(int,std::string const &)\n"
    "    FIX::FieldNotFound::FieldNotFound(int)\n"
    "    FIX::FieldNotFound::FieldNotFound()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldNotFound_field_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldNotFound *arg1 = (FIX::FieldNotFound *) 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:FieldNotFound_field_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldNotFound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldNotFound_field_set" "', argument " "1"" of type '" "FIX::FieldNotFound *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldNotFound * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldNotFound_field_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->field = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldNotFound_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldNotFound *arg1 = (FIX::FieldNotFound *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldNotFound_field_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldNotFound, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldNotFound_field_get" "', argument " "1"" of type '" "FIX::FieldNotFound *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldNotFound * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->field);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FieldNotFound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldNotFound *arg1 = (FIX::FieldNotFound *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FieldNotFound",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldNotFound, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FieldNotFound" "', argument " "1"" of type '" "FIX::FieldNotFound *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldNotFound * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FieldConvertError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::FieldConvertError *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FieldConvertError",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FieldConvertError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FieldConvertError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FieldConvertError *)new FIX::FieldConvertError((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldConvertError, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldConvertError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldConvertError *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FieldConvertError")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FieldConvertError *)new FIX::FieldConvertError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldConvertError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldConvertError(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FieldConvertError__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_FieldConvertError__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FieldConvertError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldConvertError::FieldConvertError(std::string const &)\n"
    "    FIX::FieldConvertError::FieldConvertError()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FieldConvertError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldConvertError *arg1 = (FIX::FieldConvertError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FieldConvertError",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldConvertError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FieldConvertError" "', argument " "1"" of type '" "FIX::FieldConvertError *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldConvertError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MessageParseError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::MessageParseError *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MessageParseError",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MessageParseError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MessageParseError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MessageParseError *)new FIX::MessageParseError((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageParseError, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MessageParseError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageParseError *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MessageParseError")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MessageParseError *)new FIX::MessageParseError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageParseError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MessageParseError(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MessageParseError__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_MessageParseError__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MessageParseError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MessageParseError::MessageParseError(std::string const &)\n"
    "    FIX::MessageParseError::MessageParseError()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MessageParseError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageParseError *arg1 = (FIX::MessageParseError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MessageParseError",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageParseError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageParseError" "', argument " "1"" of type '" "FIX::MessageParseError *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageParseError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_InvalidMessage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::InvalidMessage *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InvalidMessage",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvalidMessage" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvalidMessage" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InvalidMessage *)new FIX::InvalidMessage((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InvalidMessage, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidMessage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidMessage *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InvalidMessage")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InvalidMessage *)new FIX::InvalidMessage();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InvalidMessage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidMessage(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InvalidMessage__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_InvalidMessage__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InvalidMessage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InvalidMessage::InvalidMessage(std::string const &)\n"
    "    FIX::InvalidMessage::InvalidMessage()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidMessage *arg1 = (FIX::InvalidMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InvalidMessage",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InvalidMessage, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvalidMessage" "', argument " "1"" of type '" "FIX::InvalidMessage *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InvalidMessage * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ConfigError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::ConfigError *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ConfigError",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConfigError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfigError *)new FIX::ConfigError((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfigError, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfigError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfigError *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ConfigError")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfigError *)new FIX::ConfigError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfigError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfigError(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ConfigError__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_ConfigError__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ConfigError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ConfigError::ConfigError(std::string const &)\n"
    "    FIX::ConfigError::ConfigError()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConfigError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfigError *arg1 = (FIX::ConfigError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ConfigError",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ConfigError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigError" "', argument " "1"" of type '" "FIX::ConfigError *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ConfigError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RuntimeError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::RuntimeError *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RuntimeError",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RuntimeError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RuntimeError" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RuntimeError *)new FIX::RuntimeError((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RuntimeError, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RuntimeError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RuntimeError *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RuntimeError")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RuntimeError *)new FIX::RuntimeError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RuntimeError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RuntimeError(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RuntimeError__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_RuntimeError__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RuntimeError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RuntimeError::RuntimeError(std::string const &)\n"
    "    FIX::RuntimeError::RuntimeError()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RuntimeError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RuntimeError *arg1 = (FIX::RuntimeError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RuntimeError",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RuntimeError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RuntimeError" "', argument " "1"" of type '" "FIX::RuntimeError *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RuntimeError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_InvalidTagNumber__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::InvalidTagNumber *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_InvalidTagNumber",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InvalidTagNumber" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(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_InvalidTagNumber" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvalidTagNumber" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InvalidTagNumber *)new FIX::InvalidTagNumber(arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InvalidTagNumber, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidTagNumber__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InvalidTagNumber *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InvalidTagNumber",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InvalidTagNumber" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InvalidTagNumber *)new FIX::InvalidTagNumber(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InvalidTagNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidTagNumber__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidTagNumber *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InvalidTagNumber")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InvalidTagNumber *)new FIX::InvalidTagNumber();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InvalidTagNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidTagNumber(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InvalidTagNumber__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_InvalidTagNumber__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_InvalidTagNumber__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InvalidTagNumber'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InvalidTagNumber::InvalidTagNumber(int,std::string const &)\n"
    "    FIX::InvalidTagNumber::InvalidTagNumber(int)\n"
    "    FIX::InvalidTagNumber::InvalidTagNumber()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InvalidTagNumber_field_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidTagNumber *arg1 = (FIX::InvalidTagNumber *) 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:InvalidTagNumber_field_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InvalidTagNumber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvalidTagNumber_field_set" "', argument " "1"" of type '" "FIX::InvalidTagNumber *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InvalidTagNumber * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InvalidTagNumber_field_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->field = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InvalidTagNumber_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidTagNumber *arg1 = (FIX::InvalidTagNumber *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:InvalidTagNumber_field_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InvalidTagNumber, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InvalidTagNumber_field_get" "', argument " "1"" of type '" "FIX::InvalidTagNumber *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InvalidTagNumber * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->field);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InvalidTagNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidTagNumber *arg1 = (FIX::InvalidTagNumber *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InvalidTagNumber",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InvalidTagNumber, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvalidTagNumber" "', argument " "1"" of type '" "FIX::InvalidTagNumber *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InvalidTagNumber * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RequiredTagMissing__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::RequiredTagMissing *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_RequiredTagMissing",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RequiredTagMissing" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(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_RequiredTagMissing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RequiredTagMissing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RequiredTagMissing *)new FIX::RequiredTagMissing(arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RequiredTagMissing, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RequiredTagMissing__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RequiredTagMissing *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RequiredTagMissing",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RequiredTagMissing" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RequiredTagMissing *)new FIX::RequiredTagMissing(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RequiredTagMissing, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RequiredTagMissing__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RequiredTagMissing *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RequiredTagMissing")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RequiredTagMissing *)new FIX::RequiredTagMissing();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RequiredTagMissing, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RequiredTagMissing(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RequiredTagMissing__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_RequiredTagMissing__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_RequiredTagMissing__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RequiredTagMissing'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RequiredTagMissing::RequiredTagMissing(int,std::string const &)\n"
    "    FIX::RequiredTagMissing::RequiredTagMissing(int)\n"
    "    FIX::RequiredTagMissing::RequiredTagMissing()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RequiredTagMissing_field_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RequiredTagMissing *arg1 = (FIX::RequiredTagMissing *) 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:RequiredTagMissing_field_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RequiredTagMissing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequiredTagMissing_field_set" "', argument " "1"" of type '" "FIX::RequiredTagMissing *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RequiredTagMissing * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RequiredTagMissing_field_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->field = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RequiredTagMissing_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RequiredTagMissing *arg1 = (FIX::RequiredTagMissing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RequiredTagMissing_field_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RequiredTagMissing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequiredTagMissing_field_get" "', argument " "1"" of type '" "FIX::RequiredTagMissing *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RequiredTagMissing * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->field);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RequiredTagMissing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RequiredTagMissing *arg1 = (FIX::RequiredTagMissing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RequiredTagMissing",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RequiredTagMissing, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RequiredTagMissing" "', argument " "1"" of type '" "FIX::RequiredTagMissing *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RequiredTagMissing * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TagNotDefinedForMessage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::TagNotDefinedForMessage *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TagNotDefinedForMessage",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TagNotDefinedForMessage" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(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_TagNotDefinedForMessage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TagNotDefinedForMessage" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TagNotDefinedForMessage *)new FIX::TagNotDefinedForMessage(arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TagNotDefinedForMessage, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagNotDefinedForMessage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TagNotDefinedForMessage *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TagNotDefinedForMessage",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TagNotDefinedForMessage" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TagNotDefinedForMessage *)new FIX::TagNotDefinedForMessage(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TagNotDefinedForMessage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagNotDefinedForMessage__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TagNotDefinedForMessage *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TagNotDefinedForMessage")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TagNotDefinedForMessage *)new FIX::TagNotDefinedForMessage();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TagNotDefinedForMessage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagNotDefinedForMessage(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TagNotDefinedForMessage__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_TagNotDefinedForMessage__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_TagNotDefinedForMessage__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TagNotDefinedForMessage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TagNotDefinedForMessage::TagNotDefinedForMessage(int,std::string const &)\n"
    "    FIX::TagNotDefinedForMessage::TagNotDefinedForMessage(int)\n"
    "    FIX::TagNotDefinedForMessage::TagNotDefinedForMessage()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TagNotDefinedForMessage_field_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TagNotDefinedForMessage *arg1 = (FIX::TagNotDefinedForMessage *) 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:TagNotDefinedForMessage_field_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TagNotDefinedForMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TagNotDefinedForMessage_field_set" "', argument " "1"" of type '" "FIX::TagNotDefinedForMessage *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TagNotDefinedForMessage * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TagNotDefinedForMessage_field_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->field = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TagNotDefinedForMessage_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TagNotDefinedForMessage *arg1 = (FIX::TagNotDefinedForMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TagNotDefinedForMessage_field_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TagNotDefinedForMessage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TagNotDefinedForMessage_field_get" "', argument " "1"" of type '" "FIX::TagNotDefinedForMessage *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TagNotDefinedForMessage * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->field);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TagNotDefinedForMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TagNotDefinedForMessage *arg1 = (FIX::TagNotDefinedForMessage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TagNotDefinedForMessage",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TagNotDefinedForMessage, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TagNotDefinedForMessage" "', argument " "1"" of type '" "FIX::TagNotDefinedForMessage *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TagNotDefinedForMessage * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoTagValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::NoTagValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_NoTagValue",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NoTagValue" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(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_NoTagValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoTagValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTagValue *)new FIX::NoTagValue(arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTagValue, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTagValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoTagValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoTagValue",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NoTagValue" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTagValue *)new FIX::NoTagValue(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTagValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTagValue__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTagValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoTagValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTagValue *)new FIX::NoTagValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTagValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTagValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoTagValue__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_NoTagValue__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_NoTagValue__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoTagValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoTagValue::NoTagValue(int,std::string const &)\n"
    "    FIX::NoTagValue::NoTagValue(int)\n"
    "    FIX::NoTagValue::NoTagValue()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_NoTagValue_field_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTagValue *arg1 = (FIX::NoTagValue *) 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:NoTagValue_field_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoTagValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NoTagValue_field_set" "', argument " "1"" of type '" "FIX::NoTagValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoTagValue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NoTagValue_field_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->field = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NoTagValue_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTagValue *arg1 = (FIX::NoTagValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:NoTagValue_field_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoTagValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NoTagValue_field_get" "', argument " "1"" of type '" "FIX::NoTagValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoTagValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->field);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NoTagValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTagValue *arg1 = (FIX::NoTagValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoTagValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoTagValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoTagValue" "', argument " "1"" of type '" "FIX::NoTagValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoTagValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_IncorrectTagValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::IncorrectTagValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_IncorrectTagValue",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IncorrectTagValue" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(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_IncorrectTagValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IncorrectTagValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IncorrectTagValue *)new FIX::IncorrectTagValue(arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncorrectTagValue, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectTagValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IncorrectTagValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IncorrectTagValue",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IncorrectTagValue" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IncorrectTagValue *)new FIX::IncorrectTagValue(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncorrectTagValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectTagValue__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectTagValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IncorrectTagValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IncorrectTagValue *)new FIX::IncorrectTagValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncorrectTagValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectTagValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IncorrectTagValue__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_IncorrectTagValue__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_IncorrectTagValue__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IncorrectTagValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IncorrectTagValue::IncorrectTagValue(int,std::string const &)\n"
    "    FIX::IncorrectTagValue::IncorrectTagValue(int)\n"
    "    FIX::IncorrectTagValue::IncorrectTagValue()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IncorrectTagValue_field_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectTagValue *arg1 = (FIX::IncorrectTagValue *) 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:IncorrectTagValue_field_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IncorrectTagValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncorrectTagValue_field_set" "', argument " "1"" of type '" "FIX::IncorrectTagValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IncorrectTagValue * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IncorrectTagValue_field_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->field = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncorrectTagValue_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectTagValue *arg1 = (FIX::IncorrectTagValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:IncorrectTagValue_field_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IncorrectTagValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncorrectTagValue_field_get" "', argument " "1"" of type '" "FIX::IncorrectTagValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IncorrectTagValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->field);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IncorrectTagValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectTagValue *arg1 = (FIX::IncorrectTagValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IncorrectTagValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IncorrectTagValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IncorrectTagValue" "', argument " "1"" of type '" "FIX::IncorrectTagValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IncorrectTagValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_IncorrectDataFormat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::IncorrectDataFormat *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_IncorrectDataFormat",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IncorrectDataFormat" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(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_IncorrectDataFormat" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IncorrectDataFormat" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IncorrectDataFormat *)new FIX::IncorrectDataFormat(arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectDataFormat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IncorrectDataFormat *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IncorrectDataFormat",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IncorrectDataFormat" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IncorrectDataFormat *)new FIX::IncorrectDataFormat(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectDataFormat__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectDataFormat *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IncorrectDataFormat")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IncorrectDataFormat *)new FIX::IncorrectDataFormat();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectDataFormat(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IncorrectDataFormat__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_IncorrectDataFormat__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_IncorrectDataFormat__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IncorrectDataFormat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IncorrectDataFormat::IncorrectDataFormat(int,std::string const &)\n"
    "    FIX::IncorrectDataFormat::IncorrectDataFormat(int)\n"
    "    FIX::IncorrectDataFormat::IncorrectDataFormat()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IncorrectDataFormat_field_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectDataFormat *arg1 = (FIX::IncorrectDataFormat *) 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:IncorrectDataFormat_field_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IncorrectDataFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncorrectDataFormat_field_set" "', argument " "1"" of type '" "FIX::IncorrectDataFormat *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IncorrectDataFormat * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IncorrectDataFormat_field_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->field = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IncorrectDataFormat_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectDataFormat *arg1 = (FIX::IncorrectDataFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:IncorrectDataFormat_field_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IncorrectDataFormat, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncorrectDataFormat_field_get" "', argument " "1"" of type '" "FIX::IncorrectDataFormat *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IncorrectDataFormat * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->field);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IncorrectDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectDataFormat *arg1 = (FIX::IncorrectDataFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IncorrectDataFormat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IncorrectDataFormat" "', argument " "1"" of type '" "FIX::IncorrectDataFormat *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IncorrectDataFormat * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_IncorrectMessageStructure__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::IncorrectMessageStructure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IncorrectMessageStructure",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IncorrectMessageStructure" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IncorrectMessageStructure" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IncorrectMessageStructure *)new FIX::IncorrectMessageStructure((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncorrectMessageStructure, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectMessageStructure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectMessageStructure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IncorrectMessageStructure")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IncorrectMessageStructure *)new FIX::IncorrectMessageStructure();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncorrectMessageStructure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncorrectMessageStructure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IncorrectMessageStructure__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_IncorrectMessageStructure__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IncorrectMessageStructure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IncorrectMessageStructure::IncorrectMessageStructure(std::string const &)\n"
    "    FIX::IncorrectMessageStructure::IncorrectMessageStructure()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IncorrectMessageStructure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncorrectMessageStructure *arg1 = (FIX::IncorrectMessageStructure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IncorrectMessageStructure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IncorrectMessageStructure, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IncorrectMessageStructure" "', argument " "1"" of type '" "FIX::IncorrectMessageStructure *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IncorrectMessageStructure * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DuplicateFieldNumber__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::DuplicateFieldNumber *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DuplicateFieldNumber",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DuplicateFieldNumber" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DuplicateFieldNumber" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DuplicateFieldNumber *)new FIX::DuplicateFieldNumber((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DuplicateFieldNumber, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplicateFieldNumber__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DuplicateFieldNumber *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DuplicateFieldNumber")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DuplicateFieldNumber *)new FIX::DuplicateFieldNumber();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DuplicateFieldNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplicateFieldNumber(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DuplicateFieldNumber__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_DuplicateFieldNumber__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DuplicateFieldNumber'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DuplicateFieldNumber::DuplicateFieldNumber(std::string const &)\n"
    "    FIX::DuplicateFieldNumber::DuplicateFieldNumber()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DuplicateFieldNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DuplicateFieldNumber *arg1 = (FIX::DuplicateFieldNumber *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DuplicateFieldNumber",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DuplicateFieldNumber, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DuplicateFieldNumber" "', argument " "1"" of type '" "FIX::DuplicateFieldNumber *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DuplicateFieldNumber * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_InvalidMessageType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::InvalidMessageType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InvalidMessageType",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvalidMessageType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvalidMessageType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InvalidMessageType *)new FIX::InvalidMessageType((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InvalidMessageType, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidMessageType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidMessageType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InvalidMessageType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InvalidMessageType *)new FIX::InvalidMessageType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InvalidMessageType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvalidMessageType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InvalidMessageType__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_InvalidMessageType__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InvalidMessageType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InvalidMessageType::InvalidMessageType(std::string const &)\n"
    "    FIX::InvalidMessageType::InvalidMessageType()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvalidMessageType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvalidMessageType *arg1 = (FIX::InvalidMessageType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InvalidMessageType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InvalidMessageType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvalidMessageType" "', argument " "1"" of type '" "FIX::InvalidMessageType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InvalidMessageType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnsupportedMessageType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::UnsupportedMessageType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnsupportedMessageType",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnsupportedMessageType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnsupportedMessageType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnsupportedMessageType *)new FIX::UnsupportedMessageType((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnsupportedMessageType, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsupportedMessageType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnsupportedMessageType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnsupportedMessageType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnsupportedMessageType *)new FIX::UnsupportedMessageType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnsupportedMessageType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsupportedMessageType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnsupportedMessageType__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_UnsupportedMessageType__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnsupportedMessageType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnsupportedMessageType::UnsupportedMessageType(std::string const &)\n"
    "    FIX::UnsupportedMessageType::UnsupportedMessageType()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnsupportedMessageType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnsupportedMessageType *arg1 = (FIX::UnsupportedMessageType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnsupportedMessageType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnsupportedMessageType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnsupportedMessageType" "', argument " "1"" of type '" "FIX::UnsupportedMessageType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnsupportedMessageType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnsupportedVersion__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::UnsupportedVersion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnsupportedVersion",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnsupportedVersion" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnsupportedVersion" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnsupportedVersion *)new FIX::UnsupportedVersion((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnsupportedVersion, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsupportedVersion__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnsupportedVersion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnsupportedVersion")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnsupportedVersion *)new FIX::UnsupportedVersion();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnsupportedVersion, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsupportedVersion(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnsupportedVersion__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_UnsupportedVersion__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnsupportedVersion'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnsupportedVersion::UnsupportedVersion(std::string const &)\n"
    "    FIX::UnsupportedVersion::UnsupportedVersion()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnsupportedVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnsupportedVersion *arg1 = (FIX::UnsupportedVersion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnsupportedVersion",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnsupportedVersion, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnsupportedVersion" "', argument " "1"" of type '" "FIX::UnsupportedVersion *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnsupportedVersion * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TagOutOfOrder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::TagOutOfOrder *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TagOutOfOrder",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TagOutOfOrder" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(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_TagOutOfOrder" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TagOutOfOrder" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TagOutOfOrder *)new FIX::TagOutOfOrder(arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TagOutOfOrder, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagOutOfOrder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TagOutOfOrder *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TagOutOfOrder",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TagOutOfOrder" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TagOutOfOrder *)new FIX::TagOutOfOrder(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TagOutOfOrder, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagOutOfOrder__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TagOutOfOrder *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TagOutOfOrder")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TagOutOfOrder *)new FIX::TagOutOfOrder();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TagOutOfOrder, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TagOutOfOrder(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TagOutOfOrder__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_TagOutOfOrder__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_TagOutOfOrder__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TagOutOfOrder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TagOutOfOrder::TagOutOfOrder(int,std::string const &)\n"
    "    FIX::TagOutOfOrder::TagOutOfOrder(int)\n"
    "    FIX::TagOutOfOrder::TagOutOfOrder()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TagOutOfOrder_field_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TagOutOfOrder *arg1 = (FIX::TagOutOfOrder *) 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:TagOutOfOrder_field_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TagOutOfOrder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TagOutOfOrder_field_set" "', argument " "1"" of type '" "FIX::TagOutOfOrder *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TagOutOfOrder * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TagOutOfOrder_field_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->field = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TagOutOfOrder_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TagOutOfOrder *arg1 = (FIX::TagOutOfOrder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TagOutOfOrder_field_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TagOutOfOrder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TagOutOfOrder_field_get" "', argument " "1"" of type '" "FIX::TagOutOfOrder *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TagOutOfOrder * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->field);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TagOutOfOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TagOutOfOrder *arg1 = (FIX::TagOutOfOrder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TagOutOfOrder",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TagOutOfOrder, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TagOutOfOrder" "', argument " "1"" of type '" "FIX::TagOutOfOrder *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TagOutOfOrder * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RepeatedTag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::RepeatedTag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_RepeatedTag",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RepeatedTag" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(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_RepeatedTag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RepeatedTag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RepeatedTag *)new FIX::RepeatedTag(arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepeatedTag, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatedTag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RepeatedTag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RepeatedTag",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RepeatedTag" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RepeatedTag *)new FIX::RepeatedTag(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepeatedTag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatedTag__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepeatedTag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RepeatedTag")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RepeatedTag *)new FIX::RepeatedTag();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepeatedTag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatedTag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RepeatedTag__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_RepeatedTag__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_RepeatedTag__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RepeatedTag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RepeatedTag::RepeatedTag(int,std::string const &)\n"
    "    FIX::RepeatedTag::RepeatedTag(int)\n"
    "    FIX::RepeatedTag::RepeatedTag()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RepeatedTag_field_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepeatedTag *arg1 = (FIX::RepeatedTag *) 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:RepeatedTag_field_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RepeatedTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RepeatedTag_field_set" "', argument " "1"" of type '" "FIX::RepeatedTag *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RepeatedTag * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RepeatedTag_field_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->field = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RepeatedTag_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepeatedTag *arg1 = (FIX::RepeatedTag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RepeatedTag_field_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RepeatedTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RepeatedTag_field_get" "', argument " "1"" of type '" "FIX::RepeatedTag *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RepeatedTag * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->field);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RepeatedTag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepeatedTag *arg1 = (FIX::RepeatedTag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RepeatedTag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RepeatedTag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RepeatedTag" "', argument " "1"" of type '" "FIX::RepeatedTag *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RepeatedTag * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RepeatingGroupCountMismatch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_RepeatingGroupCountMismatch",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RepeatingGroupCountMismatch" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(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_RepeatingGroupCountMismatch" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RepeatingGroupCountMismatch" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RepeatingGroupCountMismatch *)new FIX::RepeatingGroupCountMismatch(arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepeatingGroupCountMismatch, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatingGroupCountMismatch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RepeatingGroupCountMismatch",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RepeatingGroupCountMismatch" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RepeatingGroupCountMismatch *)new FIX::RepeatingGroupCountMismatch(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepeatingGroupCountMismatch, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatingGroupCountMismatch__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepeatingGroupCountMismatch *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RepeatingGroupCountMismatch")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RepeatingGroupCountMismatch *)new FIX::RepeatingGroupCountMismatch();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepeatingGroupCountMismatch, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepeatingGroupCountMismatch(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RepeatingGroupCountMismatch__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_RepeatingGroupCountMismatch__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_RepeatingGroupCountMismatch__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RepeatingGroupCountMismatch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RepeatingGroupCountMismatch::RepeatingGroupCountMismatch(int,std::string const &)\n"
    "    FIX::RepeatingGroupCountMismatch::RepeatingGroupCountMismatch(int)\n"
    "    FIX::RepeatingGroupCountMismatch::RepeatingGroupCountMismatch()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RepeatingGroupCountMismatch_field_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepeatingGroupCountMismatch *arg1 = (FIX::RepeatingGroupCountMismatch *) 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:RepeatingGroupCountMismatch_field_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RepeatingGroupCountMismatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RepeatingGroupCountMismatch_field_set" "', argument " "1"" of type '" "FIX::RepeatingGroupCountMismatch *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RepeatingGroupCountMismatch * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RepeatingGroupCountMismatch_field_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->field = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RepeatingGroupCountMismatch_field_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepeatingGroupCountMismatch *arg1 = (FIX::RepeatingGroupCountMismatch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RepeatingGroupCountMismatch_field_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RepeatingGroupCountMismatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RepeatingGroupCountMismatch_field_get" "', argument " "1"" of type '" "FIX::RepeatingGroupCountMismatch *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RepeatingGroupCountMismatch * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->field);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RepeatingGroupCountMismatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepeatingGroupCountMismatch *arg1 = (FIX::RepeatingGroupCountMismatch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RepeatingGroupCountMismatch",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RepeatingGroupCountMismatch, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RepeatingGroupCountMismatch" "', argument " "1"" of type '" "FIX::RepeatingGroupCountMismatch *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RepeatingGroupCountMismatch * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DoNotSend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::DoNotSend *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DoNotSend",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoNotSend" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoNotSend" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DoNotSend *)new FIX::DoNotSend((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DoNotSend, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoNotSend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DoNotSend *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DoNotSend")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DoNotSend *)new FIX::DoNotSend();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DoNotSend, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoNotSend(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DoNotSend__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_DoNotSend__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DoNotSend'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DoNotSend::DoNotSend(std::string const &)\n"
    "    FIX::DoNotSend::DoNotSend()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DoNotSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DoNotSend *arg1 = (FIX::DoNotSend *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DoNotSend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DoNotSend, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoNotSend" "', argument " "1"" of type '" "FIX::DoNotSend *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DoNotSend * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RejectLogon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::RejectLogon *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RejectLogon",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RejectLogon" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RejectLogon" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RejectLogon *)new FIX::RejectLogon((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RejectLogon, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RejectLogon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RejectLogon *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RejectLogon")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RejectLogon *)new FIX::RejectLogon();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RejectLogon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RejectLogon(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RejectLogon__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_RejectLogon__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RejectLogon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RejectLogon::RejectLogon(std::string const &)\n"
    "    FIX::RejectLogon::RejectLogon()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RejectLogon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RejectLogon *arg1 = (FIX::RejectLogon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RejectLogon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RejectLogon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RejectLogon" "', argument " "1"" of type '" "FIX::RejectLogon *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RejectLogon * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SessionNotFound__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::SessionNotFound *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SessionNotFound",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SessionNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SessionNotFound" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SessionNotFound *)new FIX::SessionNotFound((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionNotFound, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionNotFound__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionNotFound *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SessionNotFound")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SessionNotFound *)new FIX::SessionNotFound();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionNotFound, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionNotFound(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SessionNotFound__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_SessionNotFound__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SessionNotFound'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SessionNotFound::SessionNotFound(std::string const &)\n"
    "    FIX::SessionNotFound::SessionNotFound()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SessionNotFound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionNotFound *arg1 = (FIX::SessionNotFound *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SessionNotFound",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionNotFound, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SessionNotFound" "', argument " "1"" of type '" "FIX::SessionNotFound *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionNotFound * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_IOException__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::IOException *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IOException",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IOException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOException *)new FIX::IOException((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOException, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOException__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOException *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IOException")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOException *)new FIX::IOException();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOException, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOException(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IOException__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_IOException__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IOException'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IOException::IOException(std::string const &)\n"
    "    FIX::IOException::IOException()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IOException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOException *arg1 = (FIX::IOException *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IOException",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IOException, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOException" "', argument " "1"" of type '" "FIX::IOException *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IOException * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SocketException__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketException *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SocketException")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SocketException *)new FIX::SocketException();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketException, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketException__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::SocketException *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SocketException",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SocketException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketException" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SocketException *)new FIX::SocketException((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketException, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketException(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SocketException__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_SocketException__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SocketException'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SocketException::SocketException()\n"
    "    FIX::SocketException::SocketException(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SocketException_errorToWhat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketException *arg1 = (FIX::SocketException *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SocketException_errorToWhat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SocketException, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SocketException_errorToWhat" "', argument " "1"" of type '" "FIX::SocketException *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SocketException * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->errorToWhat();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SocketException_error_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketException *arg1 = (FIX::SocketException *) 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:SocketException_error_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SocketException, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SocketException_error_set" "', argument " "1"" of type '" "FIX::SocketException *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SocketException * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SocketException_error_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->error = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SocketException_error_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketException *arg1 = (FIX::SocketException *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SocketException_error_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SocketException, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SocketException_error_get" "', argument " "1"" of type '" "FIX::SocketException *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SocketException * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int) ((arg1)->error);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SocketException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketException *arg1 = (FIX::SocketException *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SocketException",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SocketException, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SocketException" "', argument " "1"" of type '" "FIX::SocketException *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SocketException * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SocketSendFailed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketSendFailed *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SocketSendFailed")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SocketSendFailed *)new FIX::SocketSendFailed();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketSendFailed, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketSendFailed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::SocketSendFailed *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SocketSendFailed",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SocketSendFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketSendFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SocketSendFailed *)new FIX::SocketSendFailed((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketSendFailed, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketSendFailed(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SocketSendFailed__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_SocketSendFailed__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SocketSendFailed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SocketSendFailed::SocketSendFailed()\n"
    "    FIX::SocketSendFailed::SocketSendFailed(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SocketSendFailed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketSendFailed *arg1 = (FIX::SocketSendFailed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SocketSendFailed",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SocketSendFailed, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SocketSendFailed" "', argument " "1"" of type '" "FIX::SocketSendFailed *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SocketSendFailed * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SocketRecvFailed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SocketRecvFailed *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SocketRecvFailed",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SocketRecvFailed" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SocketRecvFailed *)new FIX::SocketRecvFailed(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketRecvFailed, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketRecvFailed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::SocketRecvFailed *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SocketRecvFailed",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SocketRecvFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketRecvFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SocketRecvFailed *)new FIX::SocketRecvFailed((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketRecvFailed, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketRecvFailed(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SocketRecvFailed__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_SocketRecvFailed__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SocketRecvFailed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SocketRecvFailed::SocketRecvFailed(int)\n"
    "    FIX::SocketRecvFailed::SocketRecvFailed(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SocketRecvFailed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketRecvFailed *arg1 = (FIX::SocketRecvFailed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SocketRecvFailed",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SocketRecvFailed, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SocketRecvFailed" "', argument " "1"" of type '" "FIX::SocketRecvFailed *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SocketRecvFailed * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SocketCloseFailed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketCloseFailed *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SocketCloseFailed")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SocketCloseFailed *)new FIX::SocketCloseFailed();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketCloseFailed, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketCloseFailed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::SocketCloseFailed *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SocketCloseFailed",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SocketCloseFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketCloseFailed" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SocketCloseFailed *)new FIX::SocketCloseFailed((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketCloseFailed, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketCloseFailed(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SocketCloseFailed__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_SocketCloseFailed__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SocketCloseFailed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SocketCloseFailed::SocketCloseFailed()\n"
    "    FIX::SocketCloseFailed::SocketCloseFailed(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SocketCloseFailed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketCloseFailed *arg1 = (FIX::SocketCloseFailed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SocketCloseFailed",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SocketCloseFailed, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SocketCloseFailed" "', argument " "1"" of type '" "FIX::SocketCloseFailed *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SocketCloseFailed * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FieldBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::FieldBase *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_FieldBase",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FieldBase" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(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_FieldBase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FieldBase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FieldBase *)new FIX::FieldBase(arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldBase, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FieldBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FieldBase",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldBase, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FieldBase" "', argument " "1"" of type '" "FIX::FieldBase *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_setField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 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:FieldBase_setField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldBase_setField" "', argument " "1"" of type '" "FIX::FieldBase *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldBase_setField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setField(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_setString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 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:FieldBase_setString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldBase_setString" "', argument " "1"" of type '" "FIX::FieldBase *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(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 '" "FieldBase_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FieldBase_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setString((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_getField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldBase_getField",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldBase_getField" "', argument " "1"" of type '" "FIX::FieldBase const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::FieldBase const *)arg1)->getField();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_getString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldBase_getString",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldBase_getString" "', argument " "1"" of type '" "FIX::FieldBase const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((FIX::FieldBase const *)arg1)->getString();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_getFixString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldBase_getFixString",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldBase_getFixString" "', argument " "1"" of type '" "FIX::FieldBase const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((FIX::FieldBase const *)arg1)->getFixString();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldBase_getLength",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldBase_getLength" "', argument " "1"" of type '" "FIX::FieldBase const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::FieldBase const *)arg1)->getLength();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase_getTotal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldBase_getTotal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldBase_getTotal" "', argument " "1"" of type '" "FIX::FieldBase const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::FieldBase const *)arg1)->getTotal();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  FIX::FieldBase *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:FieldBase___lt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldBase___lt__" "', argument " "1"" of type '" "FIX::FieldBase const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__FieldBase,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldBase___lt__" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FieldBase___lt__" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::FieldBase const *)arg1)->operator <((FIX::FieldBase const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldBase___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = (FIX::FieldBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldBase___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldBase___str__" "', argument " "1"" of type '" "FIX::FieldBase *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = FIX_FieldBase___str__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap___lshift____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  FIX::FieldBase *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__ostream,  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_FIX__FieldBase,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::ostream *) &FIX::operator <<(*arg1,(FIX::FieldBase const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::StringField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_StringField",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(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_StringField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StringField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StringField *)new FIX::StringField(arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StringField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StringField",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StringField *)new FIX::StringField(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StringField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StringField__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_StringField__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StringField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StringField::StringField(int,std::string const &)\n"
    "    FIX::StringField::StringField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringField_setValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 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:StringField_setValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringField_setValue" "', argument " "1"" of type '" "FIX::StringField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(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 '" "StringField_setValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringField_setValue" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setValue((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringField_getValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringField_getValue" "', argument " "1"" of type '" "FIX::StringField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((FIX::StringField const *)arg1)->getValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringField___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *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:StringField___lt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringField___lt__" "', argument " "1"" of type '" "FIX::StringField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringField___lt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringField___lt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::StringField const *)arg1)->operator <((FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringField___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *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:StringField___gt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringField___gt__" "', argument " "1"" of type '" "FIX::StringField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringField___gt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringField___gt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::StringField const *)arg1)->operator >((FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringField___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *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:StringField___eq__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringField___eq__" "', argument " "1"" of type '" "FIX::StringField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringField___eq__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringField___eq__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::StringField const *)arg1)->operator ==((FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringField___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *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:StringField___ne__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringField___ne__" "', argument " "1"" of type '" "FIX::StringField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringField___ne__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringField___ne__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::StringField const *)arg1)->operator !=((FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringField___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *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:StringField___le__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringField___le__" "', argument " "1"" of type '" "FIX::StringField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringField___le__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringField___le__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::StringField const *)arg1)->operator <=((FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringField___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  FIX::StringField *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:StringField___ge__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StringField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringField___ge__" "', argument " "1"" of type '" "FIX::StringField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringField___ge__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringField___ge__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::StringField const *)arg1)->operator >=((FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = (FIX::StringField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StringField",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StringField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringField" "', argument " "1"" of type '" "FIX::StringField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap___lt____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 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 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__lt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lt__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lt__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator <((FIX::StringField const &)*arg1,(char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__lt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lt__" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator <((char const *)arg1,(FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 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 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__gt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__gt__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__gt__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__gt__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator >((FIX::StringField const &)*arg1,(char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__gt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__gt__" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__gt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__gt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator >((char const *)arg1,(FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 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 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__eq__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator ==((FIX::StringField const &)*arg1,(char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__eq__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator ==((char const *)arg1,(FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 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 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__ne__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator !=((FIX::StringField const &)*arg1,(char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__ne__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator !=((char const *)arg1,(FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap___le____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 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 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__le__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__le__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__le__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__le__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator <=((FIX::StringField const &)*arg1,(char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap___le____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__le__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__le__" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__le__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__le__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator <=((char const *)arg1,(FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ge____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 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 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__ge__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ge__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ge__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ge__" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator >=((FIX::StringField const &)*arg1,(char const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ge____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__ge__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ge__" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ge__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ge__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator >=((char const *)arg1,(FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 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:__lt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lt__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(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 '" "__lt__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator <((FIX::StringField const &)*arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap___lt____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__lt__",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lt__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator <((std::string const &)*arg1,(FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 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:__gt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__gt__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__gt__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(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 '" "__gt__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__gt__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator >((FIX::StringField const &)*arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap___gt____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__gt__",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__gt__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__gt__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__gt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__gt__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator >((std::string const &)*arg1,(FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap___gt__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__StringField, 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___gt____SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gt____SWIG_0(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_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gt____SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gt____SWIG_1(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___eq____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 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:__eq__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(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 '" "__eq__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator ==((FIX::StringField const &)*arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap___eq____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__eq__",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator ==((std::string const &)*arg1,(FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 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:__ne__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(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 '" "__ne__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator !=((FIX::StringField const &)*arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__ne__",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator !=((std::string const &)*arg1,(FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap___le____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 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:__le__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__le__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__le__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(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 '" "__le__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__le__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator <=((FIX::StringField const &)*arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap___le____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__le__",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__le__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__le__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__le__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__le__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator <=((std::string const &)*arg1,(FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap___le__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__StringField, 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___le____SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___le____SWIG_0(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_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___le____SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___le____SWIG_1(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ge____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StringField *arg1 = 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:__ge__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ge__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ge__" "', argument " "1"" of type '" "FIX::StringField const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::StringField * >(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 '" "__ge__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ge__" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator >=((FIX::StringField const &)*arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ge____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::StringField *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__ge__",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ge__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ge__" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__StringField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ge__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ge__" "', argument " "2"" of type '" "FIX::StringField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::StringField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator >=((std::string const &)*arg1,(FIX::StringField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap___ge__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__StringField, 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___ge____SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ge____SWIG_0(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_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ge____SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ge____SWIG_1(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_new_CharField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  char arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::CharField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_CharField",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CharField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CharField" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CharField *)new FIX::CharField(arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CharField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CharField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CharField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CharField",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CharField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CharField *)new FIX::CharField(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CharField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CharField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CharField__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_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_CharField__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CharField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CharField::CharField(int,char)\n"
    "    FIX::CharField::CharField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CharField_setValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CharField *arg1 = (FIX::CharField *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CharField_setValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CharField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharField_setValue" "', argument " "1"" of type '" "FIX::CharField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CharField * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CharField_setValue" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CharField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CharField *arg1 = (FIX::CharField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CharField_getValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CharField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharField_getValue" "', argument " "1"" of type '" "FIX::CharField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CharField * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (char)((FIX::CharField const *)arg1)->getValue();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IncorrectDataFormat &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN), "FIX::IncorrectDataFormat", SWIGTYPE_p_FIX__IncorrectDataFormat); SWIG_fail;
  }
  
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CharField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CharField *arg1 = (FIX::CharField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CharField",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CharField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CharField" "', argument " "1"" of type '" "FIX::CharField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CharField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DoubleField__SWIG_0(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 ;
  FIX::DoubleField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleField",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleField" "', 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_DoubleField" "', 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_DoubleField" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DoubleField *)new FIX::DoubleField(arg1,arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DoubleField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleField__SWIG_1(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 ;
  FIX::DoubleField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_DoubleField",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleField" "', 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_DoubleField" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DoubleField *)new FIX::DoubleField(arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DoubleField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DoubleField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DoubleField",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DoubleField *)new FIX::DoubleField(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DoubleField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (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_DoubleField__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_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DoubleField__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_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_DoubleField__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DoubleField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DoubleField::DoubleField(int,double,int)\n"
    "    FIX::DoubleField::DoubleField(int,double)\n"
    "    FIX::DoubleField::DoubleField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleField_setValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DoubleField *arg1 = (FIX::DoubleField *) 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:DoubleField_setValue",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DoubleField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleField_setValue" "', argument " "1"" of type '" "FIX::DoubleField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DoubleField * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleField_setValue" "', 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 '" "DoubleField_setValue" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setValue(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleField_setValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DoubleField *arg1 = (FIX::DoubleField *) 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:DoubleField_setValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DoubleField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleField_setValue" "', argument " "1"" of type '" "FIX::DoubleField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DoubleField * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleField_setValue" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleField_setValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__DoubleField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DoubleField_setValue__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DoubleField, 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_DoubleField_setValue__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleField_setValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DoubleField::setValue(double,int)\n"
    "    FIX::DoubleField::setValue(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DoubleField *arg1 = (FIX::DoubleField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DoubleField_getValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DoubleField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleField_getValue" "', argument " "1"" of type '" "FIX::DoubleField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DoubleField * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (double)((FIX::DoubleField const *)arg1)->getValue();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IncorrectDataFormat &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN), "FIX::IncorrectDataFormat", SWIGTYPE_p_FIX__IncorrectDataFormat); SWIG_fail;
  }
  
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DoubleField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DoubleField *arg1 = (FIX::DoubleField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleField",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DoubleField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleField" "', argument " "1"" of type '" "FIX::DoubleField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DoubleField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_IntField__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 ;
  FIX::IntField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_IntField",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntField" "', 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_IntField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IntField *)new FIX::IntField(arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IntField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IntField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IntField",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IntField *)new FIX::IntField(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IntField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IntField__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_IntField__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IntField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IntField::IntField(int,int)\n"
    "    FIX::IntField::IntField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntField_setValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IntField *arg1 = (FIX::IntField *) 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:IntField_setValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IntField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntField_setValue" "', argument " "1"" of type '" "FIX::IntField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IntField * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntField_setValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IntField *arg1 = (FIX::IntField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:IntField_getValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IntField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntField_getValue" "', argument " "1"" of type '" "FIX::IntField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IntField * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (int)((FIX::IntField const *)arg1)->getValue();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IncorrectDataFormat &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN), "FIX::IncorrectDataFormat", SWIGTYPE_p_FIX__IncorrectDataFormat); SWIG_fail;
  }
  
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IntField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IntField *arg1 = (FIX::IntField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IntField",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IntField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntField" "', argument " "1"" of type '" "FIX::IntField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IntField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BoolField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  bool arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::BoolField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_BoolField",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoolField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BoolField" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BoolField *)new FIX::BoolField(arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BoolField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BoolField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BoolField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BoolField",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoolField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BoolField *)new FIX::BoolField(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BoolField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BoolField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BoolField__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_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BoolField__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BoolField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BoolField::BoolField(int,bool)\n"
    "    FIX::BoolField::BoolField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BoolField_setValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BoolField *arg1 = (FIX::BoolField *) 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:BoolField_setValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BoolField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolField_setValue" "', argument " "1"" of type '" "FIX::BoolField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BoolField * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoolField_setValue" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BoolField *arg1 = (FIX::BoolField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BoolField_getValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BoolField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolField_getValue" "', argument " "1"" of type '" "FIX::BoolField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BoolField * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)((FIX::BoolField const *)arg1)->getValue();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IncorrectDataFormat &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN), "FIX::IncorrectDataFormat", SWIGTYPE_p_FIX__IncorrectDataFormat); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoolField___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BoolField *arg1 = (FIX::BoolField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BoolField___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BoolField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoolField___nonzero__" "', argument " "1"" of type '" "FIX::BoolField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BoolField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::BoolField const *)arg1)->operator bool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BoolField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BoolField *arg1 = (FIX::BoolField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BoolField",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BoolField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoolField" "', argument " "1"" of type '" "FIX::BoolField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BoolField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UtcTimeStampField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  UtcTimeStamp *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 ;
  FIX::UtcTimeStampField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_UtcTimeStampField",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeStampField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UtcTimeStampField" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UtcTimeStampField" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeStampField" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UtcTimeStampField *)new FIX::UtcTimeStampField(arg1,(UtcTimeStamp const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStampField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStampField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  UtcTimeStamp *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::UtcTimeStampField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_UtcTimeStampField",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeStampField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UtcTimeStampField" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UtcTimeStampField" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UtcTimeStampField *)new FIX::UtcTimeStampField(arg1,(UtcTimeStamp const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStampField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStampField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  bool arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::UtcTimeStampField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_UtcTimeStampField",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeStampField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeStampField" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UtcTimeStampField *)new FIX::UtcTimeStampField(arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStampField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStampField__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UtcTimeStampField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UtcTimeStampField",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeStampField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UtcTimeStampField *)new FIX::UtcTimeStampField(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeStampField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeStampField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (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_UtcTimeStampField__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_ConvertPtr(argv[1], 0, SWIGTYPE_p_UtcTimeStamp, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UtcTimeStampField__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_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UtcTimeStampField__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_ConvertPtr(argv[1], 0, SWIGTYPE_p_UtcTimeStamp, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UtcTimeStampField__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UtcTimeStampField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UtcTimeStampField::UtcTimeStampField(int,UtcTimeStamp const &,bool)\n"
    "    FIX::UtcTimeStampField::UtcTimeStampField(int,UtcTimeStamp const &)\n"
    "    FIX::UtcTimeStampField::UtcTimeStampField(int,bool)\n"
    "    FIX::UtcTimeStampField::UtcTimeStampField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UtcTimeStampField_setValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  UtcTimeStamp *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:UtcTimeStampField_setValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcTimeStampField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcTimeStampField_setValue" "', argument " "1"" of type '" "FIX::UtcTimeStampField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStampField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcTimeStampField_setValue" "', argument " "2"" of type '" "UtcTimeStamp &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UtcTimeStampField_setValue" "', argument " "2"" of type '" "UtcTimeStamp &""'"); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setValue(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeStampField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  UtcTimeStamp result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UtcTimeStampField_getValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcTimeStampField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcTimeStampField_getValue" "', argument " "1"" of type '" "FIX::UtcTimeStampField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStampField * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = ((FIX::UtcTimeStampField const *)arg1)->getValue();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IncorrectDataFormat &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN), "FIX::IncorrectDataFormat", SWIGTYPE_p_FIX__IncorrectDataFormat); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj((new UtcTimeStamp(static_cast< const UtcTimeStamp& >(result))), SWIGTYPE_p_UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeStampField___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  FIX::UtcTimeStampField *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:UtcTimeStampField___lt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcTimeStampField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcTimeStampField___lt__" "', argument " "1"" of type '" "FIX::UtcTimeStampField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStampField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__UtcTimeStampField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcTimeStampField___lt__" "', argument " "2"" of type '" "FIX::UtcTimeStampField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UtcTimeStampField___lt__" "', argument " "2"" of type '" "FIX::UtcTimeStampField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStampField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::UtcTimeStampField const *)arg1)->operator <((FIX::UtcTimeStampField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeStampField___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  FIX::UtcTimeStampField *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:UtcTimeStampField___eq__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcTimeStampField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcTimeStampField___eq__" "', argument " "1"" of type '" "FIX::UtcTimeStampField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStampField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__UtcTimeStampField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcTimeStampField___eq__" "', argument " "2"" of type '" "FIX::UtcTimeStampField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UtcTimeStampField___eq__" "', argument " "2"" of type '" "FIX::UtcTimeStampField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStampField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::UtcTimeStampField const *)arg1)->operator ==((FIX::UtcTimeStampField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeStampField___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  FIX::UtcTimeStampField *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:UtcTimeStampField___ne__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcTimeStampField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcTimeStampField___ne__" "', argument " "1"" of type '" "FIX::UtcTimeStampField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStampField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__UtcTimeStampField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcTimeStampField___ne__" "', argument " "2"" of type '" "FIX::UtcTimeStampField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UtcTimeStampField___ne__" "', argument " "2"" of type '" "FIX::UtcTimeStampField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStampField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::UtcTimeStampField const *)arg1)->operator !=((FIX::UtcTimeStampField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UtcTimeStampField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeStampField *arg1 = (FIX::UtcTimeStampField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UtcTimeStampField",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcTimeStampField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UtcTimeStampField" "', argument " "1"" of type '" "FIX::UtcTimeStampField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeStampField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UtcDateField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  UtcDate *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::UtcDateField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_UtcDateField",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcDateField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UtcDate,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UtcDateField" "', argument " "2"" of type '" "UtcDate const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UtcDateField" "', argument " "2"" of type '" "UtcDate const &""'"); 
  }
  arg2 = reinterpret_cast< UtcDate * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UtcDateField *)new FIX::UtcDateField(arg1,(UtcDate const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcDateField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcDateField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UtcDateField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UtcDateField",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcDateField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UtcDateField *)new FIX::UtcDateField(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcDateField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcDateField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UtcDateField__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_ConvertPtr(argv[1], 0, SWIGTYPE_p_UtcDate, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UtcDateField__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UtcDateField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UtcDateField::UtcDateField(int,UtcDate const &)\n"
    "    FIX::UtcDateField::UtcDateField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UtcDateField_setValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  UtcDate *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:UtcDateField_setValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcDateField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcDateField_setValue" "', argument " "1"" of type '" "FIX::UtcDateField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcDateField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UtcDate,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcDateField_setValue" "', argument " "2"" of type '" "UtcDate &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UtcDateField_setValue" "', argument " "2"" of type '" "UtcDate &""'"); 
  }
  arg2 = reinterpret_cast< UtcDate * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setValue(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcDateField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  UtcDate result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UtcDateField_getValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcDateField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcDateField_getValue" "', argument " "1"" of type '" "FIX::UtcDateField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcDateField * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = ((FIX::UtcDateField const *)arg1)->getValue();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IncorrectDataFormat &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN), "FIX::IncorrectDataFormat", SWIGTYPE_p_FIX__IncorrectDataFormat); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj((new UtcDate(static_cast< const UtcDate& >(result))), SWIGTYPE_p_UtcDate, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcDateField___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  FIX::UtcDateField *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:UtcDateField___lt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcDateField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcDateField___lt__" "', argument " "1"" of type '" "FIX::UtcDateField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcDateField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__UtcDateField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcDateField___lt__" "', argument " "2"" of type '" "FIX::UtcDateField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UtcDateField___lt__" "', argument " "2"" of type '" "FIX::UtcDateField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcDateField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::UtcDateField const *)arg1)->operator <((FIX::UtcDateField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcDateField___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  FIX::UtcDateField *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:UtcDateField___eq__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcDateField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcDateField___eq__" "', argument " "1"" of type '" "FIX::UtcDateField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcDateField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__UtcDateField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcDateField___eq__" "', argument " "2"" of type '" "FIX::UtcDateField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UtcDateField___eq__" "', argument " "2"" of type '" "FIX::UtcDateField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcDateField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::UtcDateField const *)arg1)->operator ==((FIX::UtcDateField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcDateField___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  FIX::UtcDateField *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:UtcDateField___ne__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcDateField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcDateField___ne__" "', argument " "1"" of type '" "FIX::UtcDateField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcDateField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__UtcDateField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcDateField___ne__" "', argument " "2"" of type '" "FIX::UtcDateField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UtcDateField___ne__" "', argument " "2"" of type '" "FIX::UtcDateField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcDateField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::UtcDateField const *)arg1)->operator !=((FIX::UtcDateField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UtcDateField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcDateField *arg1 = (FIX::UtcDateField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UtcDateField",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcDateField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UtcDateField" "', argument " "1"" of type '" "FIX::UtcDateField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcDateField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UtcTimeOnlyField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  UtcTimeOnly *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 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_UtcTimeOnlyField",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeOnlyField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UtcTimeOnly,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UtcTimeOnlyField" "', argument " "2"" of type '" "UtcTimeOnly const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UtcTimeOnlyField" "', argument " "2"" of type '" "UtcTimeOnly const &""'"); 
  }
  arg2 = reinterpret_cast< UtcTimeOnly * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UtcTimeOnlyField" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UtcTimeOnlyField *)new FIX::UtcTimeOnlyField(arg1,(UtcTimeOnly const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnlyField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnlyField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  UtcTimeOnly *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_UtcTimeOnlyField",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeOnlyField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UtcTimeOnly,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UtcTimeOnlyField" "', argument " "2"" of type '" "UtcTimeOnly const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UtcTimeOnlyField" "', argument " "2"" of type '" "UtcTimeOnly const &""'"); 
  }
  arg2 = reinterpret_cast< UtcTimeOnly * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UtcTimeOnlyField *)new FIX::UtcTimeOnlyField(arg1,(UtcTimeOnly const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnlyField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnlyField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  bool arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_UtcTimeOnlyField",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeOnlyField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UtcTimeOnlyField" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UtcTimeOnlyField *)new FIX::UtcTimeOnlyField(arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnlyField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnlyField__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UtcTimeOnlyField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UtcTimeOnlyField",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UtcTimeOnlyField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UtcTimeOnlyField *)new FIX::UtcTimeOnlyField(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UtcTimeOnlyField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UtcTimeOnlyField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (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_UtcTimeOnlyField__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_ConvertPtr(argv[1], 0, SWIGTYPE_p_UtcTimeOnly, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UtcTimeOnlyField__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_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UtcTimeOnlyField__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_ConvertPtr(argv[1], 0, SWIGTYPE_p_UtcTimeOnly, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UtcTimeOnlyField__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UtcTimeOnlyField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UtcTimeOnlyField::UtcTimeOnlyField(int,UtcTimeOnly const &,bool)\n"
    "    FIX::UtcTimeOnlyField::UtcTimeOnlyField(int,UtcTimeOnly const &)\n"
    "    FIX::UtcTimeOnlyField::UtcTimeOnlyField(int,bool)\n"
    "    FIX::UtcTimeOnlyField::UtcTimeOnlyField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UtcTimeOnlyField_setValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  UtcTimeOnly *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:UtcTimeOnlyField_setValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcTimeOnlyField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcTimeOnlyField_setValue" "', argument " "1"" of type '" "FIX::UtcTimeOnlyField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UtcTimeOnly,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcTimeOnlyField_setValue" "', argument " "2"" of type '" "UtcTimeOnly &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UtcTimeOnlyField_setValue" "', argument " "2"" of type '" "UtcTimeOnly &""'"); 
  }
  arg2 = reinterpret_cast< UtcTimeOnly * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setValue(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeOnlyField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  UtcTimeOnly result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UtcTimeOnlyField_getValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcTimeOnlyField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcTimeOnlyField_getValue" "', argument " "1"" of type '" "FIX::UtcTimeOnlyField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = ((FIX::UtcTimeOnlyField const *)arg1)->getValue();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IncorrectDataFormat &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN), "FIX::IncorrectDataFormat", SWIGTYPE_p_FIX__IncorrectDataFormat); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj((new UtcTimeOnly(static_cast< const UtcTimeOnly& >(result))), SWIGTYPE_p_UtcTimeOnly, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeOnlyField___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  FIX::UtcTimeOnlyField *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:UtcTimeOnlyField___lt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcTimeOnlyField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcTimeOnlyField___lt__" "', argument " "1"" of type '" "FIX::UtcTimeOnlyField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__UtcTimeOnlyField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcTimeOnlyField___lt__" "', argument " "2"" of type '" "FIX::UtcTimeOnlyField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UtcTimeOnlyField___lt__" "', argument " "2"" of type '" "FIX::UtcTimeOnlyField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::UtcTimeOnlyField const *)arg1)->operator <((FIX::UtcTimeOnlyField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeOnlyField___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  FIX::UtcTimeOnlyField *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:UtcTimeOnlyField___eq__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcTimeOnlyField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcTimeOnlyField___eq__" "', argument " "1"" of type '" "FIX::UtcTimeOnlyField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__UtcTimeOnlyField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcTimeOnlyField___eq__" "', argument " "2"" of type '" "FIX::UtcTimeOnlyField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UtcTimeOnlyField___eq__" "', argument " "2"" of type '" "FIX::UtcTimeOnlyField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::UtcTimeOnlyField const *)arg1)->operator ==((FIX::UtcTimeOnlyField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UtcTimeOnlyField___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  FIX::UtcTimeOnlyField *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:UtcTimeOnlyField___ne__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcTimeOnlyField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UtcTimeOnlyField___ne__" "', argument " "1"" of type '" "FIX::UtcTimeOnlyField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__UtcTimeOnlyField,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UtcTimeOnlyField___ne__" "', argument " "2"" of type '" "FIX::UtcTimeOnlyField const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UtcTimeOnlyField___ne__" "', argument " "2"" of type '" "FIX::UtcTimeOnlyField const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::UtcTimeOnlyField const *)arg1)->operator !=((FIX::UtcTimeOnlyField const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UtcTimeOnlyField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UtcTimeOnlyField *arg1 = (FIX::UtcTimeOnlyField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UtcTimeOnlyField",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UtcTimeOnlyField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UtcTimeOnlyField" "', argument " "1"" of type '" "FIX::UtcTimeOnlyField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UtcTimeOnlyField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CheckSumField__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 ;
  FIX::CheckSumField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_CheckSumField",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CheckSumField" "', 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_CheckSumField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CheckSumField *)new FIX::CheckSumField(arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CheckSumField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CheckSumField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CheckSumField *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CheckSumField",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CheckSumField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CheckSumField *)new FIX::CheckSumField(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CheckSumField, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CheckSumField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CheckSumField__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_CheckSumField__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CheckSumField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CheckSumField::CheckSumField(int,int)\n"
    "    FIX::CheckSumField::CheckSumField(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CheckSumField_setValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CheckSumField *arg1 = (FIX::CheckSumField *) 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:CheckSumField_setValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CheckSumField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckSumField_setValue" "', argument " "1"" of type '" "FIX::CheckSumField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CheckSumField * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CheckSumField_setValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CheckSumField_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CheckSumField *arg1 = (FIX::CheckSumField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CheckSumField_getValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CheckSumField, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckSumField_getValue" "', argument " "1"" of type '" "FIX::CheckSumField const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CheckSumField * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (int)((FIX::CheckSumField const *)arg1)->getValue();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IncorrectDataFormat &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN), "FIX::IncorrectDataFormat", SWIGTYPE_p_FIX__IncorrectDataFormat); SWIG_fail;
  }
  
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CheckSumField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CheckSumField *arg1 = (FIX::CheckSumField *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CheckSumField",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CheckSumField, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CheckSumField" "', argument " "1"" of type '" "FIX::CheckSumField *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CheckSumField * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FieldMap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  message_order *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FieldMap *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FieldMap",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FieldMap" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FieldMap" "', argument " "1"" of type '" "message_order const &""'"); 
  }
  arg1 = reinterpret_cast< message_order * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FieldMap *)new FIX::FieldMap((message_order const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldMap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FieldMap")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FieldMap *)new FIX::FieldMap();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldMap__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int *arg1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FieldMap *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FieldMap",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FieldMap" "', argument " "1"" of type '" "int const []""'"); 
  } 
  arg1 = reinterpret_cast< int * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FieldMap *)new FIX::FieldMap((int const (*))arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldMap__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FieldMap *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FieldMap",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FieldMap,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FieldMap" "', argument " "1"" of type '" "FIX::FieldMap const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FieldMap" "', argument " "1"" of type '" "FIX::FieldMap const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FieldMap *)new FIX::FieldMap((FIX::FieldMap const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FieldMap(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FieldMap__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_message_order, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FieldMap__SWIG_0(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FieldMap__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FieldMap__SWIG_3(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FieldMap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::FieldMap(message_order const &)\n"
    "    FIX::FieldMap::FieldMap()\n"
    "    FIX::FieldMap::FieldMap(int const [])\n"
    "    FIX::FieldMap::FieldMap(FIX::FieldMap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FieldMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FieldMap",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FieldMap" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_setField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  FIX::FieldBase *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:FieldMap_setField",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_setField" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__FieldBase,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldMap_setField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FieldMap_setField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FieldMap_setField" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setField((FIX::FieldBase const &)*arg2,arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::RepeatedTag &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::RepeatedTag(static_cast< const FIX::RepeatedTag& >(_e))),SWIGTYPE_p_FIX__RepeatedTag,SWIG_POINTER_OWN), "FIX::RepeatedTag", SWIGTYPE_p_FIX__RepeatedTag); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_setField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  FIX::FieldBase *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:FieldMap_setField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_setField" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__FieldBase,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldMap_setField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FieldMap_setField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setField((FIX::FieldBase const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::RepeatedTag &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::RepeatedTag(static_cast< const FIX::RepeatedTag& >(_e))),SWIGTYPE_p_FIX__RepeatedTag,SWIG_POINTER_OWN), "FIX::RepeatedTag", SWIGTYPE_p_FIX__RepeatedTag); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_setField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:FieldMap_setField",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_setField" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_setField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(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 '" "FieldMap_setField" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FieldMap_setField" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setField(arg2,(std::string const &)*arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::RepeatedTag &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::RepeatedTag(static_cast< const FIX::RepeatedTag& >(_e))),SWIGTYPE_p_FIX__RepeatedTag,SWIG_POINTER_OWN), "FIX::RepeatedTag", SWIGTYPE_p_FIX__RepeatedTag); SWIG_fail;
  }
  catch(FIX::NoTagValue &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::NoTagValue(static_cast< const FIX::NoTagValue& >(_e))),SWIGTYPE_p_FIX__NoTagValue,SWIG_POINTER_OWN), "FIX::NoTagValue", SWIGTYPE_p_FIX__NoTagValue); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_setField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__FieldBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FieldMap_setField__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__FieldBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FieldMap_setField__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 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_FieldMap_setField__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FieldMap_setField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::setField(FIX::FieldBase const &,bool)\n"
    "    FIX::FieldMap::setField(FIX::FieldBase const &)\n"
    "    FIX::FieldMap::setField(int,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_getField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  FIX::FieldBase *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::FieldBase *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FieldMap_getField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_getField" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__FieldBase,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldMap_getField" "', argument " "2"" of type '" "FIX::FieldBase &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FieldMap_getField" "', argument " "2"" of type '" "FIX::FieldBase &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::FieldBase *) &((FIX::FieldMap const *)arg1)->getField(*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::FieldNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FieldMap_getField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_getField" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_getField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (std::string *) &((FIX::FieldMap const *)arg1)->getField(arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::FieldNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__FieldBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FieldMap_getField__SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_getField__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FieldMap_getField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::getField(FIX::FieldBase &) const\n"
    "    FIX::FieldMap::getField(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_getFieldRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::FieldBase *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FieldMap_getFieldRef",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_getFieldRef" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_getFieldRef" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::FieldBase *) &((FIX::FieldMap const *)arg1)->getFieldRef(arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::FieldNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getFieldPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::FieldBase *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FieldMap_getFieldPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_getFieldPtr" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_getFieldPtr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::FieldBase *)((FIX::FieldMap const *)arg1)->getFieldPtr(arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::FieldNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldBase, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_isSetField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  FIX::FieldBase *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:FieldMap_isSetField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_isSetField" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__FieldBase,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FieldMap_isSetField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FieldMap_isSetField" "', argument " "2"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::FieldBase * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::FieldMap const *)arg1)->isSetField((FIX::FieldBase const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_isSetField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 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:FieldMap_isSetField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_isSetField" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_isSetField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::FieldMap const *)arg1)->isSetField(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_isSetField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__FieldBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FieldMap_isSetField__SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_isSetField__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FieldMap_isSetField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::isSetField(FIX::FieldBase const &) const\n"
    "    FIX::FieldMap::isSetField(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_removeField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 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:FieldMap_removeField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_removeField" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_removeField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->removeField(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_addGroup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  FIX::FieldMap *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:FieldMap_addGroup",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_addGroup" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_addGroup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__FieldMap,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FieldMap_addGroup" "', argument " "3"" of type '" "FIX::FieldMap const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FieldMap_addGroup" "', argument " "3"" of type '" "FIX::FieldMap const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::FieldMap * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FieldMap_addGroup" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addGroup(arg2,(FIX::FieldMap const &)*arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_addGroup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  FIX::FieldMap *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:FieldMap_addGroup",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_addGroup" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_addGroup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__FieldMap,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FieldMap_addGroup" "', argument " "3"" of type '" "FIX::FieldMap const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FieldMap_addGroup" "', argument " "3"" of type '" "FIX::FieldMap const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::FieldMap * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addGroup(arg2,(FIX::FieldMap const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_addGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__FieldMap, 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_FIX__FieldMap, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_FieldMap_addGroup__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 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_FIX__FieldMap, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FieldMap_addGroup__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FieldMap_addGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::addGroup(int,FIX::FieldMap const &,bool)\n"
    "    FIX::FieldMap::addGroup(int,FIX::FieldMap const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_replaceGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  int arg3 ;
  FIX::FieldMap *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:FieldMap_replaceGroup",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_replaceGroup" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_replaceGroup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FieldMap_replaceGroup" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_FIX__FieldMap,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FieldMap_replaceGroup" "', argument " "4"" of type '" "FIX::FieldMap &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FieldMap_replaceGroup" "', argument " "4"" of type '" "FIX::FieldMap &""'"); 
  }
  arg4 = reinterpret_cast< FIX::FieldMap * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->replaceGroup(arg2,arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  int arg2 ;
  int arg3 ;
  FIX::FieldMap *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 ;
  FIX::FieldMap *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:FieldMap_getGroup",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_getGroup" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_getGroup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FieldMap_getGroup" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_FIX__FieldMap,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FieldMap_getGroup" "', argument " "4"" of type '" "FIX::FieldMap &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FieldMap_getGroup" "', argument " "4"" of type '" "FIX::FieldMap &""'"); 
  }
  arg4 = reinterpret_cast< FIX::FieldMap * >(argp4);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::FieldMap *) &((FIX::FieldMap const *)arg1)->getGroup(arg2,arg3,*arg4);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::FieldNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getGroupRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 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 ;
  FIX::FieldMap *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:FieldMap_getGroupRef",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_getGroupRef" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_getGroupRef" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FieldMap_getGroupRef" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::FieldMap *) &((FIX::FieldMap const *)arg1)->getGroupRef(arg2,arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::FieldNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_getGroupPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 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 ;
  FIX::FieldMap *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:FieldMap_getGroupPtr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_getGroupPtr" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_getGroupPtr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FieldMap_getGroupPtr" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::FieldMap *)((FIX::FieldMap const *)arg1)->getGroupPtr(arg2,arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::FieldNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_removeGroup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 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:FieldMap_removeGroup",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_removeGroup" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_removeGroup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FieldMap_removeGroup" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->removeGroup(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_removeGroup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 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:FieldMap_removeGroup",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_removeGroup" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_removeGroup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->removeGroup(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_removeGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_removeGroup__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 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_FieldMap_removeGroup__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FieldMap_removeGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::removeGroup(int,int)\n"
    "    FIX::FieldMap::removeGroup(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_hasGroup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 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:FieldMap_hasGroup",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_hasGroup" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_hasGroup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::FieldMap const *)arg1)->hasGroup(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_hasGroup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 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:FieldMap_hasGroup",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_hasGroup" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_hasGroup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FieldMap_hasGroup" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::FieldMap const *)arg1)->hasGroup(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_hasGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_hasGroup__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 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_FieldMap_hasGroup__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FieldMap_hasGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::hasGroup(int) const\n"
    "    FIX::FieldMap::hasGroup(int,int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_groupCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 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:FieldMap_groupCount",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_groupCount" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_groupCount" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::FieldMap const *)arg1)->groupCount(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldMap_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_clear" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_isEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldMap_isEmpty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_isEmpty" "', argument " "1"" of type '" "FIX::FieldMap *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->isEmpty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_totalFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldMap_totalFields",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_totalFields" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::FieldMap const *)arg1)->totalFields();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:FieldMap_calculateString",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_calculateString" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    temp2 = std::string((char*)PyString_AsString(obj1));
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FieldMap_calculateString" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((FIX::FieldMap const *)arg1)->calculateString(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FieldMap_calculateString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_calculateString" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    temp2 = std::string((char*)PyString_AsString(obj1));
    arg2 = &temp2;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((FIX::FieldMap const *)arg1)->calculateString(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateString(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FieldMap_calculateString__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_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_FieldMap_calculateString__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FieldMap_calculateString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::calculateString(std::string &,bool) const\n"
    "    FIX::FieldMap::calculateString(std::string &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateLength__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 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:FieldMap_calculateLength",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_calculateLength" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_calculateLength" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FieldMap_calculateLength" "', 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 '" "FieldMap_calculateLength" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::FieldMap const *)arg1)->calculateLength(arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateLength__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 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:FieldMap_calculateLength",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_calculateLength" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_calculateLength" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FieldMap_calculateLength" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::FieldMap const *)arg1)->calculateLength(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateLength__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 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:FieldMap_calculateLength",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_calculateLength" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_calculateLength" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::FieldMap const *)arg1)->calculateLength(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateLength__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldMap_calculateLength",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_calculateLength" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::FieldMap const *)arg1)->calculateLength();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateLength(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FieldMap_calculateLength__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_calculateLength__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 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_FieldMap_calculateLength__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 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_FieldMap_calculateLength__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FieldMap_calculateLength'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::calculateLength(int,int,int) const\n"
    "    FIX::FieldMap::calculateLength(int,int) const\n"
    "    FIX::FieldMap::calculateLength(int) const\n"
    "    FIX::FieldMap::calculateLength() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateTotal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 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:FieldMap_calculateTotal",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_calculateTotal" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FieldMap_calculateTotal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::FieldMap const *)arg1)->calculateTotal(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateTotal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldMap_calculateTotal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_calculateTotal" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::FieldMap const *)arg1)->calculateTotal();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_calculateTotal(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FieldMap_calculateTotal__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FieldMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FieldMap_calculateTotal__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FieldMap_calculateTotal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FieldMap::calculateTotal(int) const\n"
    "    FIX::FieldMap::calculateTotal() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FieldMap_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FieldMap::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldMap_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_begin" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::FieldMap const *)arg1)->begin();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new FIX::FieldMap::iterator(static_cast< const FIX::FieldMap::iterator& >(result))), SWIGTYPE_p_FIX__FieldMap__Fields__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FieldMap::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldMap_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_end" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::FieldMap const *)arg1)->end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new FIX::FieldMap::iterator(static_cast< const FIX::FieldMap::iterator& >(result))), SWIGTYPE_p_FIX__FieldMap__Fields__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_g_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FieldMap::g_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldMap_g_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_g_begin" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::FieldMap const *)arg1)->g_begin();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new FIX::FieldMap::g_iterator(static_cast< const FIX::FieldMap::g_iterator& >(result))), SWIGTYPE_p_FIX__FieldMap__Groups__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FieldMap_g_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldMap *arg1 = (FIX::FieldMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FieldMap::g_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FieldMap_g_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FieldMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FieldMap_g_end" "', argument " "1"" of type '" "FIX::FieldMap const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldMap * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::FieldMap const *)arg1)->g_end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new FIX::FieldMap::g_iterator(static_cast< const FIX::FieldMap::g_iterator& >(result))), SWIGTYPE_p_FIX__FieldMap__Groups__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN int Swig_var_headerOrder_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable headerOrder is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_headerOrder_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(FIX::headerOrder), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_Header(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Header *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Header")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Header *)new FIX::Header();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Header, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Header(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Header *arg1 = (FIX::Header *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Header",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Header, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Header" "', argument " "1"" of type '" "FIX::Header *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Header * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Trailer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Trailer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Trailer")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Trailer *)new FIX::Trailer();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Trailer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Trailer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Trailer *arg1 = (FIX::Trailer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Trailer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Trailer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Trailer" "', argument " "1"" of type '" "FIX::Trailer *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Trailer * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Message__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Message")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Message *)new FIX::Message();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::Message *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Message",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Message" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::InvalidMessage &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN), "FIX::InvalidMessage", SWIGTYPE_p_FIX__InvalidMessage); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::Message *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Message",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::Message *)new FIX::Message((std::string const &)*arg1);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::InvalidMessage &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN), "FIX::InvalidMessage", SWIGTYPE_p_FIX__InvalidMessage); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::DataDictionary *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  FIX::Message *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Message",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Message" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2,arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::InvalidMessage &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN), "FIX::InvalidMessage", SWIGTYPE_p_FIX__InvalidMessage); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::DataDictionary *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::Message *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Message",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::InvalidMessage &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN), "FIX::InvalidMessage", SWIGTYPE_p_FIX__InvalidMessage); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::DataDictionary *arg2 = 0 ;
  FIX::DataDictionary *arg3 = 0 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  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 ;
  FIX::Message *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Message",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Message" "', argument " "3"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Message" "', argument " "3"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::DataDictionary * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Message" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2,(FIX::DataDictionary const &)*arg3,arg4);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::InvalidMessage &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN), "FIX::InvalidMessage", SWIGTYPE_p_FIX__InvalidMessage); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::DataDictionary *arg2 = 0 ;
  FIX::DataDictionary *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  FIX::Message *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Message",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Message" "', argument " "2"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Message" "', argument " "3"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Message" "', argument " "3"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::DataDictionary * >(argp3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::Message *)new FIX::Message((std::string const &)*arg1,(FIX::DataDictionary const &)*arg2,(FIX::DataDictionary const &)*arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::InvalidMessage &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN), "FIX::InvalidMessage", SWIGTYPE_p_FIX__InvalidMessage); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Message *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Message",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Message,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Message" "', argument " "1"" of type '" "FIX::Message const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Message *)new FIX::Message((FIX::Message const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Message, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Message(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Message__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Message__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_Message__SWIG_2(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_FIX__DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Message__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_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Message__SWIG_1(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_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__DataDictionary, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Message__SWIG_6(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_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Message__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_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__DataDictionary, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Message__SWIG_5(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Message'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::Message()\n"
    "    FIX::Message::Message(std::string const &,bool)\n"
    "    FIX::Message::Message(std::string const &)\n"
    "    FIX::Message::Message(std::string const &,FIX::DataDictionary const &,bool)\n"
    "    FIX::Message::Message(std::string const &,FIX::DataDictionary const &)\n"
    "    FIX::Message::Message(std::string const &,FIX::DataDictionary const &,FIX::DataDictionary const &,bool)\n"
    "    FIX::Message::Message(std::string const &,FIX::DataDictionary const &,FIX::DataDictionary const &)\n"
    "    FIX::Message::Message(FIX::Message const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_InitializeXML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_InitializeXML",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_InitializeXML" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_InitializeXML" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::Message::InitializeXML((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_addGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  FIX::Group *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:Message_addGroup",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_addGroup" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_addGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_addGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addGroup(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_replaceGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  unsigned int arg2 ;
  FIX::Group *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:Message_replaceGroup",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_replaceGroup" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Message_replaceGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message_replaceGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_replaceGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->replaceGroup(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  unsigned int arg2 ;
  FIX::Group *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 ;
  Group *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Message_getGroup",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_getGroup" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Message_getGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message_getGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_getGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (Group *) &((FIX::Message const *)arg1)->getGroup(arg2,*arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::FieldNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Group, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_removeGroup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  unsigned int arg2 ;
  FIX::Group *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:Message_removeGroup",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_removeGroup" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Message_removeGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message_removeGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_removeGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->removeGroup(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_removeGroup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  FIX::Group *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:Message_removeGroup",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_removeGroup" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_removeGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_removeGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->removeGroup(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_removeGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__Group, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_removeGroup__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__Group, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Message_removeGroup__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Message_removeGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::removeGroup(unsigned int,FIX::Group &)\n"
    "    FIX::Message::removeGroup(FIX::Group &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_hasGroup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  FIX::Group *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:Message_hasGroup",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_hasGroup" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_hasGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_hasGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::Message const *)arg1)->hasGroup((FIX::Group const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_hasGroup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  unsigned int arg2 ;
  FIX::Group *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 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Message_hasGroup",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_hasGroup" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Message_hasGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message_hasGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_hasGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::Message const *)arg1)->hasGroup(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_hasGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__Group, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_hasGroup__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__Group, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Message_hasGroup__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Message_hasGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::hasGroup(FIX::Group const &) const\n"
    "    FIX::Message::hasGroup(unsigned int,FIX::Group &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 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 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Message_toString",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Message_toString" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Message_toString" "', 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 '" "Message_toString" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::Message const *)arg1)->toString(arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 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::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Message_toString",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Message_toString" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Message_toString" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::Message const *)arg1)->toString(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 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:Message_toString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Message_toString" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::Message const *)arg1)->toString(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_toString",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::Message const *)arg1)->toString();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  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 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Message_toString",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    temp2 = std::string((char*)PyString_AsString(obj1));
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Message_toString" "', 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 '" "Message_toString" "', 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 '" "Message_toString" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((FIX::Message const *)arg1)->toString(*arg2,arg3,arg4,arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Message_toString",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    temp2 = std::string((char*)PyString_AsString(obj1));
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Message_toString" "', 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 '" "Message_toString" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((FIX::Message const *)arg1)->toString(*arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Message_toString",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    temp2 = std::string((char*)PyString_AsString(obj1));
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Message_toString" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((FIX::Message const *)arg1)->toString(*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Message_toString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_toString" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    temp2 = std::string((char*)PyString_AsString(obj1));
    arg2 = &temp2;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((FIX::Message const *)arg1)->toString(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toString(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_toString__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_toString__SWIG_7(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Message_toString__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_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_Message_toString__SWIG_6(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 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_Message_toString__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_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_Message_toString__SWIG_5(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 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_Message_toString__SWIG_0(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_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_Message_toString__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Message_toString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::toString(int,int,int) const\n"
    "    FIX::Message::toString(int,int) const\n"
    "    FIX::Message::toString(int) const\n"
    "    FIX::Message::toString() const\n"
    "    FIX::Message::toString(std::string &,int,int,int) const\n"
    "    FIX::Message::toString(std::string &,int,int) const\n"
    "    FIX::Message::toString(std::string &,int) const\n"
    "    FIX::Message::toString(std::string &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_toXML__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_toXML",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_toXML" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::Message const *)arg1)->toXML();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toXML__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Message_toXML",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_toXML" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    temp2 = std::string((char*)PyString_AsString(obj1));
    arg2 = &temp2;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((FIX::Message const *)arg1)->toXML(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toXML(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_toXML__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_toXML__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Message_toXML'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::toXML() const\n"
    "    FIX::Message::toXML(std::string &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_reverseRoute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  FIX::Header *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:Message_reverseRoute",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_reverseRoute" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Header,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_reverseRoute" "', argument " "2"" of type '" "FIX::Header const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_reverseRoute" "', argument " "2"" of type '" "FIX::Header const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Header * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->reverseRoute((FIX::Header const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_setString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 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:Message_setString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setString" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(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 '" "Message_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setString((std::string const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::InvalidMessage &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN), "FIX::InvalidMessage", SWIGTYPE_p_FIX__InvalidMessage); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_setString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Message_setString",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setString" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(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 '" "Message_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Message_setString" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setString((std::string const &)*arg2,arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::InvalidMessage &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN), "FIX::InvalidMessage", SWIGTYPE_p_FIX__InvalidMessage); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_setString__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  FIX::DataDictionary *arg4 = (FIX::DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool 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:Message_setString",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setString" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(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 '" "Message_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Message_setString" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Message_setString" "', argument " "4"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg4 = reinterpret_cast< FIX::DataDictionary * >(argp4);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setString((std::string const &)*arg2,arg3,(FIX::DataDictionary const *)arg4);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::InvalidMessage &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN), "FIX::InvalidMessage", SWIGTYPE_p_FIX__InvalidMessage); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_setString__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  FIX::DataDictionary *arg4 = (FIX::DataDictionary *) 0 ;
  FIX::DataDictionary *arg5 = (FIX::DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool 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 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Message_setString",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setString" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(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 '" "Message_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Message_setString" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Message_setString" "', argument " "4"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg4 = reinterpret_cast< FIX::DataDictionary * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Message_setString" "', argument " "5"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg5 = reinterpret_cast< FIX::DataDictionary * >(argp5);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setString((std::string const &)*arg2,arg3,(FIX::DataDictionary const *)arg4,(FIX::DataDictionary const *)arg5);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::InvalidMessage &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::InvalidMessage(static_cast< const FIX::InvalidMessage& >(_e))),SWIGTYPE_p_FIX__InvalidMessage,SWIG_POINTER_OWN), "FIX::InvalidMessage", SWIGTYPE_p_FIX__InvalidMessage); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_setString(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[6];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Message, 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_Message_setString__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 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_Message_setString__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Message_setString__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Message_setString__SWIG_3(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Message_setString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::setString(std::string const &)\n"
    "    FIX::Message::setString(std::string const &,bool)\n"
    "    FIX::Message::setString(std::string const &,bool,FIX::DataDictionary const *)\n"
    "    FIX::Message::setString(std::string const &,bool,FIX::DataDictionary const *,FIX::DataDictionary const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_setGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  FIX::FieldBase *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string::size_type *arg5 = 0 ;
  FIX::FieldMap *arg6 = 0 ;
  DataDictionary *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  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:Message_setGroup",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setGroup" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(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 '" "Message_setGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_setGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__FieldBase,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message_setGroup" "', argument " "3"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_setGroup" "', argument " "3"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::FieldBase * >(argp3);
  {
    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 '" "Message_setGroup" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_setGroup" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__string__size_type,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Message_setGroup" "', argument " "5"" of type '" "std::string::size_type &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_setGroup" "', argument " "5"" of type '" "std::string::size_type &""'"); 
  }
  arg5 = reinterpret_cast< std::string::size_type * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_FIX__FieldMap,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Message_setGroup" "', argument " "6"" of type '" "FIX::FieldMap &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_setGroup" "', argument " "6"" of type '" "FIX::FieldMap &""'"); 
  }
  arg6 = reinterpret_cast< FIX::FieldMap * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Message_setGroup" "', argument " "7"" of type '" "DataDictionary const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_setGroup" "', argument " "7"" of type '" "DataDictionary const &""'"); 
  }
  arg7 = reinterpret_cast< DataDictionary * >(argp7);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setGroup((std::string const &)*arg2,(FIX::FieldBase const &)*arg3,(std::string const &)*arg4,*arg5,*arg6,(DataDictionary const &)*arg7);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_setStringHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 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:Message_setStringHeader",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setStringHeader" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(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 '" "Message_setStringHeader" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_setStringHeader" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->setStringHeader((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getHeader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Header *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_getHeader",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_getHeader" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Header *) &((FIX::Message const *)arg1)->getHeader();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Header, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getHeader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Header *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_getHeader",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_getHeader" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Header *) &(arg1)->getHeader();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Header, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getHeader(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getHeader__SWIG_1(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getHeader__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Message_getHeader'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::getHeader() const\n"
    "    FIX::Message::getHeader()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_getTrailer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Trailer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_getTrailer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_getTrailer" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Trailer *) &((FIX::Message const *)arg1)->getTrailer();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Trailer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getTrailer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Trailer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_getTrailer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_getTrailer" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Trailer *) &(arg1)->getTrailer();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Trailer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getTrailer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getTrailer__SWIG_1(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getTrailer__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Message_getTrailer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::getTrailer() const\n"
    "    FIX::Message::getTrailer()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_hasValidStructure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Message_hasValidStructure",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_hasValidStructure" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_AsVal_int(obj1, &temp2); 	 
    arg2 = &temp2;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::Message const *)arg1)->hasValidStructure(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("int &") == "int &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyInt_FromLong(*arg2) ); 	 
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_bodyLength__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 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:Message_bodyLength",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_bodyLength" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Message_bodyLength" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Message_bodyLength" "', 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 '" "Message_bodyLength" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::Message const *)arg1)->bodyLength(arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_bodyLength__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 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:Message_bodyLength",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_bodyLength" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Message_bodyLength" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Message_bodyLength" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::Message const *)arg1)->bodyLength(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_bodyLength__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 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:Message_bodyLength",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_bodyLength" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Message_bodyLength" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::Message const *)arg1)->bodyLength(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_bodyLength__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_bodyLength",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_bodyLength" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::Message const *)arg1)->bodyLength();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_bodyLength(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_bodyLength__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Message_bodyLength__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 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_Message_bodyLength__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 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_Message_bodyLength__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Message_bodyLength'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::bodyLength(int,int,int) const\n"
    "    FIX::Message::bodyLength(int,int) const\n"
    "    FIX::Message::bodyLength(int) const\n"
    "    FIX::Message::bodyLength() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_checkSum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 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:Message_checkSum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_checkSum" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Message_checkSum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::Message const *)arg1)->checkSum(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_checkSum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_checkSum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_checkSum" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::Message const *)arg1)->checkSum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_checkSum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_checkSum__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Message_checkSum__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Message_checkSum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::checkSum(int) const\n"
    "    FIX::Message::checkSum() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_isAdmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_isAdmin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_isAdmin" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::Message const *)arg1)->isAdmin();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_isApp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_isApp" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::Message const *)arg1)->isApp();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_isEmpty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_isEmpty" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->isEmpty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_clear" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isAdminMsgType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  MsgType *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_isAdminMsgType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_MsgType,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_isAdminMsgType" "', argument " "1"" of type '" "MsgType const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_isAdminMsgType" "', argument " "1"" of type '" "MsgType const &""'"); 
  }
  arg1 = reinterpret_cast< MsgType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::Message::isAdminMsgType((MsgType const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toApplVerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  BeginString *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  ApplVerID result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_toApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_BeginString,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_toApplVerID" "', argument " "1"" of type '" "BeginString const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_toApplVerID" "', argument " "1"" of type '" "BeginString const &""'"); 
  }
  arg1 = reinterpret_cast< BeginString * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = FIX::Message::toApplVerID((BeginString const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new ApplVerID(static_cast< const ApplVerID& >(result))), SWIGTYPE_p_ApplVerID, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_toBeginString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ApplVerID *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  BeginString result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_toBeginString",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_ApplVerID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_toBeginString" "', argument " "1"" of type '" "ApplVerID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_toBeginString" "', argument " "1"" of type '" "ApplVerID const &""'"); 
  }
  arg1 = reinterpret_cast< ApplVerID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = FIX::Message::toBeginString((ApplVerID const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new BeginString(static_cast< const BeginString& >(result))), SWIGTYPE_p_BeginString, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isHeaderField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_isHeaderField",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Message_isHeaderField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::Message::isHeaderField(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isHeaderField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = 0 ;
  DataDictionary *arg2 = (DataDictionary *) 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:Message_isHeaderField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FieldBase,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_isHeaderField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_isHeaderField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_isHeaderField" "', argument " "2"" of type '" "DataDictionary const *""'"); 
  }
  arg2 = reinterpret_cast< DataDictionary * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::Message::isHeaderField((FIX::FieldBase const &)*arg1,(DataDictionary const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isHeaderField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_isHeaderField",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FieldBase,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_isHeaderField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_isHeaderField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::Message::isHeaderField((FIX::FieldBase const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isHeaderField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__FieldBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_isHeaderField__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_Message_isHeaderField__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FieldBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_isHeaderField__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Message_isHeaderField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::isHeaderField(int)\n"
    "    FIX::Message::isHeaderField(FIX::FieldBase const &,DataDictionary const *)\n"
    "    FIX::Message::isHeaderField(FIX::FieldBase const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_isTrailerField__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_isTrailerField",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Message_isTrailerField" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::Message::isTrailerField(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isTrailerField__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = 0 ;
  DataDictionary *arg2 = (DataDictionary *) 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:Message_isTrailerField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FieldBase,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_isTrailerField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_isTrailerField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_isTrailerField" "', argument " "2"" of type '" "DataDictionary const *""'"); 
  }
  arg2 = reinterpret_cast< DataDictionary * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::Message::isTrailerField((FIX::FieldBase const &)*arg1,(DataDictionary const *)arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isTrailerField__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FieldBase *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_isTrailerField",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FieldBase,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_isTrailerField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_isTrailerField" "', argument " "1"" of type '" "FIX::FieldBase const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FieldBase * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::Message::isTrailerField((FIX::FieldBase const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_isTrailerField(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__FieldBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_isTrailerField__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_Message_isTrailerField__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FieldBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Message_isTrailerField__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Message_isTrailerField'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::isTrailerField(int)\n"
    "    FIX::Message::isTrailerField(FIX::FieldBase const &,DataDictionary const *)\n"
    "    FIX::Message::isTrailerField(FIX::FieldBase const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_getSessionID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SessionID result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Message_getSessionID",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_getSessionID" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(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 '" "Message_getSessionID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_getSessionID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = ((FIX::Message const *)arg1)->getSessionID((std::string const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::FieldNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj((new SessionID(static_cast< const SessionID& >(result))), SWIGTYPE_p_SessionID, SWIG_POINTER_OWN |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getSessionID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SessionID result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message_getSessionID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_getSessionID" "', argument " "1"" of type '" "FIX::Message const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = ((FIX::Message const *)arg1)->getSessionID();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::FieldNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj((new SessionID(static_cast< const SessionID& >(result))), SWIGTYPE_p_SessionID, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message_getSessionID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Message_getSessionID__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 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_Message_getSessionID__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Message_getSessionID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Message::getSessionID(std::string const &) const\n"
    "    FIX::Message::getSessionID() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Message_setSessionID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  SessionID *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:Message_setSessionID",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_setSessionID" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_setSessionID" "', argument " "2"" of type '" "SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Message_setSessionID" "', argument " "2"" of type '" "SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setSessionID((SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Message___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Message___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___str__" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = FIX_Message___str__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Message(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = (FIX::Message *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Message",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Message, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Message" "', argument " "1"" of type '" "FIX::Message *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Message_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Message, 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 ;
  FIX::Message *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__ostream,  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_FIX__Message,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::ostream *) &FIX::operator <<(*arg1,(FIX::Message const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_identifyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  MsgType result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:identifyType",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "identifyType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "identifyType" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = FIX::identifyType((std::string const &)*arg1);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::MessageParseError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::MessageParseError(static_cast< const FIX::MessageParseError& >(_e))),SWIGTYPE_p_FIX__MessageParseError,SWIG_POINTER_OWN), "FIX::MessageParseError", SWIGTYPE_p_FIX__MessageParseError); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj((new MsgType(static_cast< const MsgType& >(result))), SWIGTYPE_p_MsgType, SWIG_POINTER_OWN |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Group__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 ;
  FIX::Group *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Group",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Group" "', 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_Group" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Group *)new FIX::Group(arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Group, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Group__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 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  FIX::Group *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Group",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Group" "', 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_Group" "', 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 '" "new_Group" "', argument " "3"" of type '" "int const []""'"); 
  } 
  arg3 = reinterpret_cast< int * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Group *)new FIX::Group(arg1,arg2,(int const (*))arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Group, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Group__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  message_order *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 ;
  FIX::Group *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Group",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Group" "', 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_Group" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_message_order,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Group" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Group" "', argument " "3"" of type '" "message_order const &""'"); 
  }
  arg3 = reinterpret_cast< message_order * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Group *)new FIX::Group(arg1,arg2,(message_order const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Group, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Group__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Group *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Group",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Group" "', argument " "1"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Group" "', argument " "1"" of type '" "FIX::Group const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Group *)new FIX::Group((FIX::Group const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Group, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Group(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__Group, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Group__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_Group__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_ConvertPtr(argv[2], 0, SWIGTYPE_p_message_order, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Group__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) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Group__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Group'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Group::Group(int,int)\n"
    "    FIX::Group::Group(int,int,int const [])\n"
    "    FIX::Group::Group(int,int,message_order const &)\n"
    "    FIX::Group::Group(FIX::Group const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Group_field(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Group_field",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_field" "', argument " "1"" of type '" "FIX::Group const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::Group const *)arg1)->field();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_delim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Group_delim",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_delim" "', argument " "1"" of type '" "FIX::Group const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::Group const *)arg1)->delim();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_addGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  FIX::Group *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:Group_addGroup",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_addGroup" "', argument " "1"" of type '" "FIX::Group *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_addGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Group_addGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addGroup(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_replaceGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  unsigned int arg2 ;
  FIX::Group *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:Group_replaceGroup",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_replaceGroup" "', argument " "1"" of type '" "FIX::Group *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_replaceGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Group_replaceGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Group_replaceGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->replaceGroup(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_getGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  unsigned int arg2 ;
  FIX::Group *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 ;
  FIX::Group *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Group_getGroup",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_getGroup" "', argument " "1"" of type '" "FIX::Group const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_getGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Group_getGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Group_getGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::Group *) &((FIX::Group const *)arg1)->getGroup(arg2,*arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::FieldNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Group, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_removeGroup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  unsigned int arg2 ;
  FIX::Group *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:Group_removeGroup",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_removeGroup" "', argument " "1"" of type '" "FIX::Group *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_removeGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Group_removeGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Group_removeGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->removeGroup(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_removeGroup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  FIX::Group *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:Group_removeGroup",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_removeGroup" "', argument " "1"" of type '" "FIX::Group *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_removeGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Group_removeGroup" "', argument " "2"" of type '" "FIX::Group &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->removeGroup(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_removeGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Group, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__Group, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Group_removeGroup__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Group, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__Group, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Group_removeGroup__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Group_removeGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Group::removeGroup(unsigned int,FIX::Group &)\n"
    "    FIX::Group::removeGroup(FIX::Group &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Group_hasGroup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  FIX::Group *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:Group_hasGroup",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_hasGroup" "', argument " "1"" of type '" "FIX::Group *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Group,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_hasGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Group_hasGroup" "', argument " "2"" of type '" "FIX::Group const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Group * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->hasGroup((FIX::Group const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_hasGroup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  unsigned int arg2 ;
  FIX::Group *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 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Group_hasGroup",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Group, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_hasGroup" "', argument " "1"" of type '" "FIX::Group *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_hasGroup" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__Group,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Group_hasGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Group_hasGroup" "', argument " "3"" of type '" "FIX::Group &""'"); 
  }
  arg3 = reinterpret_cast< FIX::Group * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->hasGroup(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Group_hasGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Group, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__Group, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Group_hasGroup__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Group, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__Group, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Group_hasGroup__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Group_hasGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Group::hasGroup(FIX::Group const &)\n"
    "    FIX::Group::hasGroup(unsigned int,FIX::Group &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Group *arg1 = (FIX::Group *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Group",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Group, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Group" "', argument " "1"" of type '" "FIX::Group *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Group * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MaxPriceLevels__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaxPriceLevels *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaxPriceLevels")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaxPriceLevels *)new FIX::MaxPriceLevels();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaxPriceLevels, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxPriceLevels__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaxPriceLevels *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaxPriceLevels",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaxPriceLevels" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaxPriceLevels" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaxPriceLevels *)new FIX::MaxPriceLevels((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaxPriceLevels, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxPriceLevels(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaxPriceLevels__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaxPriceLevels__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaxPriceLevels'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaxPriceLevels::MaxPriceLevels()\n"
    "    FIX::MaxPriceLevels::MaxPriceLevels(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaxPriceLevels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaxPriceLevels *arg1 = (FIX::MaxPriceLevels *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaxPriceLevels",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaxPriceLevels, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaxPriceLevels" "', argument " "1"" of type '" "FIX::MaxPriceLevels *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaxPriceLevels * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeEncodedIssuer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEncodedIssuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeEncodedIssuer")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEncodedIssuer *)new FIX::DerivativeEncodedIssuer();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEncodedIssuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedIssuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeEncodedIssuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeEncodedIssuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeEncodedIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeEncodedIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEncodedIssuer *)new FIX::DerivativeEncodedIssuer((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEncodedIssuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedIssuer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeEncodedIssuer__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEncodedIssuer__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeEncodedIssuer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeEncodedIssuer::DerivativeEncodedIssuer()\n"
    "    FIX::DerivativeEncodedIssuer::DerivativeEncodedIssuer(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeEncodedIssuer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEncodedIssuer *arg1 = (FIX::DerivativeEncodedIssuer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeEncodedIssuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeEncodedIssuer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeEncodedIssuer" "', argument " "1"" of type '" "FIX::DerivativeEncodedIssuer *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeEncodedIssuer * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoCompIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoCompIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoCompIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoCompIDs *)new FIX::NoCompIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoCompIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoCompIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoCompIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoCompIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoCompIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoCompIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoCompIDs *)new FIX::NoCompIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoCompIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoCompIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoCompIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoCompIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoCompIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoCompIDs::NoCompIDs()\n"
    "    FIX::NoCompIDs::NoCompIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoCompIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoCompIDs *arg1 = (FIX::NoCompIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoCompIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoCompIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoCompIDs" "', argument " "1"" of type '" "FIX::NoCompIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoCompIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlInstRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlInstRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstRefID *)new FIX::SettlInstRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlInstRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlInstRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlInstRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlInstRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstRefID *)new FIX::SettlInstRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlInstRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlInstRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlInstRefID::SettlInstRefID()\n"
    "    FIX::SettlInstRefID::SettlInstRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlInstRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstRefID *arg1 = (FIX::SettlInstRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlInstRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlInstRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlInstRefID" "', argument " "1"" of type '" "FIX::SettlInstRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlInstRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NestedPartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NestedPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NestedPartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NestedPartyID *)new FIX::NestedPartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NestedPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NestedPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NestedPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NestedPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NestedPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NestedPartyID *)new FIX::NestedPartyID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NestedPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NestedPartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NestedPartyID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NestedPartyID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NestedPartyID::NestedPartyID()\n"
    "    FIX::NestedPartyID::NestedPartyID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NestedPartyID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NestedPartyID *arg1 = (FIX::NestedPartyID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NestedPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NestedPartyID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NestedPartyID" "', argument " "1"" of type '" "FIX::NestedPartyID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NestedPartyID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DetachmentPoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DetachmentPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DetachmentPoint")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DetachmentPoint *)new FIX::DetachmentPoint();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DetachmentPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DetachmentPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DetachmentPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DetachmentPoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DetachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DetachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DetachmentPoint *)new FIX::DetachmentPoint((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DetachmentPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DetachmentPoint(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DetachmentPoint__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DetachmentPoint__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DetachmentPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DetachmentPoint::DetachmentPoint()\n"
    "    FIX::DetachmentPoint::DetachmentPoint(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DetachmentPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DetachmentPoint *arg1 = (FIX::DetachmentPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DetachmentPoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DetachmentPoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DetachmentPoint" "', argument " "1"" of type '" "FIX::DetachmentPoint *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DetachmentPoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LateIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LateIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LateIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LateIndicator *)new FIX::LateIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LateIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LateIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LateIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LateIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LateIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LateIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LateIndicator *)new FIX::LateIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LateIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LateIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LateIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LateIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LateIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LateIndicator::LateIndicator()\n"
    "    FIX::LateIndicator::LateIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LateIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LateIndicator *arg1 = (FIX::LateIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LateIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LateIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LateIndicator" "', argument " "1"" of type '" "FIX::LateIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LateIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecurityListID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityListID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityListID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityListID *)new FIX::SecurityListID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityListID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityListID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityListID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityListID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityListID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityListID *)new FIX::SecurityListID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityListID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityListID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityListID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityListID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityListID::SecurityListID()\n"
    "    FIX::SecurityListID::SecurityListID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityListID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityListID *arg1 = (FIX::SecurityListID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityListID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityListID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityListID" "', argument " "1"" of type '" "FIX::SecurityListID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityListID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeFlowScheduleType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeFlowScheduleType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeFlowScheduleType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeFlowScheduleType *)new FIX::DerivativeFlowScheduleType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeFlowScheduleType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeFlowScheduleType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeFlowScheduleType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeFlowScheduleType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeFlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeFlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeFlowScheduleType *)new FIX::DerivativeFlowScheduleType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeFlowScheduleType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeFlowScheduleType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeFlowScheduleType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeFlowScheduleType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeFlowScheduleType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeFlowScheduleType::DerivativeFlowScheduleType()\n"
    "    FIX::DerivativeFlowScheduleType::DerivativeFlowScheduleType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeFlowScheduleType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeFlowScheduleType *arg1 = (FIX::DerivativeFlowScheduleType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeFlowScheduleType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeFlowScheduleType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeFlowScheduleType" "', argument " "1"" of type '" "FIX::DerivativeFlowScheduleType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeFlowScheduleType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FlexibleIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FlexibleIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FlexibleIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FlexibleIndicator *)new FIX::FlexibleIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FlexibleIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlexibleIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FlexibleIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FlexibleIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlexibleIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlexibleIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FlexibleIndicator *)new FIX::FlexibleIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FlexibleIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlexibleIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FlexibleIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FlexibleIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FlexibleIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FlexibleIndicator::FlexibleIndicator()\n"
    "    FIX::FlexibleIndicator::FlexibleIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FlexibleIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FlexibleIndicator *arg1 = (FIX::FlexibleIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FlexibleIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FlexibleIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FlexibleIndicator" "', argument " "1"" of type '" "FIX::FlexibleIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FlexibleIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoExecInstRules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoExecInstRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoExecInstRules")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoExecInstRules *)new FIX::NoExecInstRules();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoExecInstRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoExecInstRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoExecInstRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoExecInstRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoExecInstRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoExecInstRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoExecInstRules *)new FIX::NoExecInstRules((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoExecInstRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoExecInstRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoExecInstRules__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoExecInstRules__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoExecInstRules'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoExecInstRules::NoExecInstRules()\n"
    "    FIX::NoExecInstRules::NoExecInstRules(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoExecInstRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoExecInstRules *arg1 = (FIX::NoExecInstRules *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoExecInstRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoExecInstRules, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoExecInstRules" "', argument " "1"" of type '" "FIX::NoExecInstRules *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoExecInstRules * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestamp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideTrdRegTimestamp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideTrdRegTimestamp")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTrdRegTimestamp *)new FIX::SideTrdRegTimestamp();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTrdRegTimestamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestamp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideTrdRegTimestamp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideTrdRegTimestamp",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SideTrdRegTimestamp" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTrdRegTimestamp *)new FIX::SideTrdRegTimestamp(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTrdRegTimestamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestamp__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideTrdRegTimestamp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideTrdRegTimestamp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideTrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideTrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTrdRegTimestamp *)new FIX::SideTrdRegTimestamp((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTrdRegTimestamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestamp__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::SideTrdRegTimestamp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_SideTrdRegTimestamp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideTrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideTrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SideTrdRegTimestamp" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTrdRegTimestamp *)new FIX::SideTrdRegTimestamp((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTrdRegTimestamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestamp(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideTrdRegTimestamp__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideTrdRegTimestamp__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_SideTrdRegTimestamp__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SideTrdRegTimestamp__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideTrdRegTimestamp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideTrdRegTimestamp::SideTrdRegTimestamp()\n"
    "    FIX::SideTrdRegTimestamp::SideTrdRegTimestamp(bool)\n"
    "    FIX::SideTrdRegTimestamp::SideTrdRegTimestamp(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::SideTrdRegTimestamp::SideTrdRegTimestamp(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideTrdRegTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideTrdRegTimestamp *arg1 = (FIX::SideTrdRegTimestamp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideTrdRegTimestamp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideTrdRegTimestamp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideTrdRegTimestamp" "', argument " "1"" of type '" "FIX::SideTrdRegTimestamp *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideTrdRegTimestamp * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DeliveryForm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeliveryForm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DeliveryForm")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeliveryForm *)new FIX::DeliveryForm();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeliveryForm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliveryForm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DeliveryForm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DeliveryForm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeliveryForm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeliveryForm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeliveryForm *)new FIX::DeliveryForm((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeliveryForm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliveryForm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DeliveryForm__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeliveryForm__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DeliveryForm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DeliveryForm::DeliveryForm()\n"
    "    FIX::DeliveryForm::DeliveryForm(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DeliveryForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeliveryForm *arg1 = (FIX::DeliveryForm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DeliveryForm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DeliveryForm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeliveryForm" "', argument " "1"" of type '" "FIX::DeliveryForm *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DeliveryForm * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ExecRestatementReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecRestatementReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExecRestatementReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecRestatementReason *)new FIX::ExecRestatementReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecRestatementReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecRestatementReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExecRestatementReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExecRestatementReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExecRestatementReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExecRestatementReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecRestatementReason *)new FIX::ExecRestatementReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecRestatementReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecRestatementReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExecRestatementReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecRestatementReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExecRestatementReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExecRestatementReason::ExecRestatementReason()\n"
    "    FIX::ExecRestatementReason::ExecRestatementReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExecRestatementReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecRestatementReason *arg1 = (FIX::ExecRestatementReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExecRestatementReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExecRestatementReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExecRestatementReason" "', argument " "1"" of type '" "FIX::ExecRestatementReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExecRestatementReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MidYield__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MidYield *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MidYield")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MidYield *)new FIX::MidYield();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MidYield, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MidYield__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MidYield *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MidYield",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MidYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MidYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MidYield *)new FIX::MidYield((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MidYield, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MidYield(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MidYield__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MidYield__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MidYield'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MidYield::MidYield()\n"
    "    FIX::MidYield::MidYield(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MidYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MidYield *arg1 = (FIX::MidYield *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MidYield",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MidYield, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MidYield" "', argument " "1"" of type '" "FIX::MidYield *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MidYield * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ContractMultiplier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContractMultiplier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ContractMultiplier")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContractMultiplier *)new FIX::ContractMultiplier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContractMultiplier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContractMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContractMultiplier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContractMultiplier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContractMultiplier *)new FIX::ContractMultiplier((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContractMultiplier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContractMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ContractMultiplier__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContractMultiplier__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContractMultiplier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ContractMultiplier::ContractMultiplier()\n"
    "    FIX::ContractMultiplier::ContractMultiplier(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ContractMultiplier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContractMultiplier *arg1 = (FIX::ContractMultiplier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContractMultiplier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ContractMultiplier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContractMultiplier" "', argument " "1"" of type '" "FIX::ContractMultiplier *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ContractMultiplier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CcyAmt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CcyAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CcyAmt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CcyAmt *)new FIX::CcyAmt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CcyAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CcyAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CcyAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CcyAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CcyAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CcyAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CcyAmt *)new FIX::CcyAmt((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CcyAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CcyAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CcyAmt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CcyAmt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CcyAmt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CcyAmt::CcyAmt()\n"
    "    FIX::CcyAmt::CcyAmt(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CcyAmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CcyAmt *arg1 = (FIX::CcyAmt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CcyAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CcyAmt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CcyAmt" "', argument " "1"" of type '" "FIX::CcyAmt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CcyAmt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegOrderQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegOrderQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegOrderQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegOrderQty *)new FIX::LegOrderQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegOrderQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOrderQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegOrderQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegOrderQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegOrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegOrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegOrderQty *)new FIX::LegOrderQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegOrderQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOrderQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegOrderQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegOrderQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegOrderQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegOrderQty::LegOrderQty()\n"
    "    FIX::LegOrderQty::LegOrderQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegOrderQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegOrderQty *arg1 = (FIX::LegOrderQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegOrderQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegOrderQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegOrderQty" "', argument " "1"" of type '" "FIX::LegOrderQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegOrderQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AllocIntermedReqType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocIntermedReqType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocIntermedReqType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocIntermedReqType *)new FIX::AllocIntermedReqType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocIntermedReqType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocIntermedReqType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocIntermedReqType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocIntermedReqType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocIntermedReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocIntermedReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocIntermedReqType *)new FIX::AllocIntermedReqType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocIntermedReqType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocIntermedReqType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocIntermedReqType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocIntermedReqType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocIntermedReqType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocIntermedReqType::AllocIntermedReqType()\n"
    "    FIX::AllocIntermedReqType::AllocIntermedReqType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocIntermedReqType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocIntermedReqType *arg1 = (FIX::AllocIntermedReqType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocIntermedReqType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocIntermedReqType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocIntermedReqType" "', argument " "1"" of type '" "FIX::AllocIntermedReqType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocIntermedReqType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingIssuer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingIssuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingIssuer")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingIssuer *)new FIX::UnderlyingIssuer();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingIssuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingIssuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingIssuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingIssuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingIssuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingIssuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingIssuer *)new FIX::UnderlyingIssuer((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingIssuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingIssuer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingIssuer__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingIssuer__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingIssuer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingIssuer::UnderlyingIssuer()\n"
    "    FIX::UnderlyingIssuer::UnderlyingIssuer(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingIssuer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingIssuer *arg1 = (FIX::UnderlyingIssuer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingIssuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingIssuer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingIssuer" "', argument " "1"" of type '" "FIX::UnderlyingIssuer *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingIssuer * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoNested2PartyIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNested2PartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoNested2PartyIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNested2PartyIDs *)new FIX::NoNested2PartyIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNested2PartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested2PartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoNested2PartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoNested2PartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoNested2PartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoNested2PartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNested2PartyIDs *)new FIX::NoNested2PartyIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNested2PartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested2PartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoNested2PartyIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNested2PartyIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoNested2PartyIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoNested2PartyIDs::NoNested2PartyIDs()\n"
    "    FIX::NoNested2PartyIDs::NoNested2PartyIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoNested2PartyIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNested2PartyIDs *arg1 = (FIX::NoNested2PartyIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoNested2PartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoNested2PartyIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoNested2PartyIDs" "', argument " "1"" of type '" "FIX::NoNested2PartyIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoNested2PartyIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MinTradeVol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinTradeVol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MinTradeVol")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MinTradeVol *)new FIX::MinTradeVol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MinTradeVol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinTradeVol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MinTradeVol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MinTradeVol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MinTradeVol" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MinTradeVol" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MinTradeVol *)new FIX::MinTradeVol((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MinTradeVol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinTradeVol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MinTradeVol__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinTradeVol__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MinTradeVol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MinTradeVol::MinTradeVol()\n"
    "    FIX::MinTradeVol::MinTradeVol(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MinTradeVol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinTradeVol *arg1 = (FIX::MinTradeVol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MinTradeVol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MinTradeVol, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MinTradeVol" "', argument " "1"" of type '" "FIX::MinTradeVol *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MinTradeVol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlCurrAmt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlCurrAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlCurrAmt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlCurrAmt *)new FIX::SettlCurrAmt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlCurrAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlCurrAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlCurrAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlCurrAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlCurrAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlCurrAmt *)new FIX::SettlCurrAmt((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlCurrAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlCurrAmt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlCurrAmt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlCurrAmt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlCurrAmt::SettlCurrAmt()\n"
    "    FIX::SettlCurrAmt::SettlCurrAmt(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlCurrAmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlCurrAmt *arg1 = (FIX::SettlCurrAmt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlCurrAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlCurrAmt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlCurrAmt" "', argument " "1"" of type '" "FIX::SettlCurrAmt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlCurrAmt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrumentPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeInstrumentPartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrumentPartyRole *)new FIX::DerivativeInstrumentPartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrumentPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeInstrumentPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeInstrumentPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeInstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeInstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrumentPartyRole *)new FIX::DerivativeInstrumentPartyRole((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrumentPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeInstrumentPartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrumentPartyRole__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeInstrumentPartyRole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeInstrumentPartyRole::DerivativeInstrumentPartyRole()\n"
    "    FIX::DerivativeInstrumentPartyRole::DerivativeInstrumentPartyRole(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeInstrumentPartyRole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrumentPartyRole *arg1 = (FIX::DerivativeInstrumentPartyRole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeInstrumentPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeInstrumentPartyRole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeInstrumentPartyRole" "', argument " "1"" of type '" "FIX::DerivativeInstrumentPartyRole *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeInstrumentPartyRole * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_YieldRedemptionPriceType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::YieldRedemptionPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_YieldRedemptionPriceType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::YieldRedemptionPriceType *)new FIX::YieldRedemptionPriceType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__YieldRedemptionPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldRedemptionPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::YieldRedemptionPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_YieldRedemptionPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YieldRedemptionPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YieldRedemptionPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::YieldRedemptionPriceType *)new FIX::YieldRedemptionPriceType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__YieldRedemptionPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldRedemptionPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_YieldRedemptionPriceType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YieldRedemptionPriceType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_YieldRedemptionPriceType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::YieldRedemptionPriceType::YieldRedemptionPriceType()\n"
    "    FIX::YieldRedemptionPriceType::YieldRedemptionPriceType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YieldRedemptionPriceType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::YieldRedemptionPriceType *arg1 = (FIX::YieldRedemptionPriceType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_YieldRedemptionPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__YieldRedemptionPriceType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YieldRedemptionPriceType" "', argument " "1"" of type '" "FIX::YieldRedemptionPriceType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::YieldRedemptionPriceType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NewsRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NewsRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NewsRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NewsRefID *)new FIX::NewsRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NewsRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NewsRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NewsRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewsRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NewsRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NewsRefID *)new FIX::NewsRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NewsRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NewsRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NewsRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NewsRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NewsRefID::NewsRefID()\n"
    "    FIX::NewsRefID::NewsRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NewsRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NewsRefID *arg1 = (FIX::NewsRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NewsRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NewsRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewsRefID" "', argument " "1"" of type '" "FIX::NewsRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NewsRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecurityListTypeSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityListTypeSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityListTypeSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityListTypeSource *)new FIX::SecurityListTypeSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityListTypeSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListTypeSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityListTypeSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityListTypeSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityListTypeSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityListTypeSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityListTypeSource *)new FIX::SecurityListTypeSource((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityListTypeSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListTypeSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityListTypeSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityListTypeSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityListTypeSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityListTypeSource::SecurityListTypeSource()\n"
    "    FIX::SecurityListTypeSource::SecurityListTypeSource(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityListTypeSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityListTypeSource *arg1 = (FIX::SecurityListTypeSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityListTypeSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityListTypeSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityListTypeSource" "', argument " "1"" of type '" "FIX::SecurityListTypeSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityListTypeSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ApplReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplReqID *)new FIX::ApplReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplReqID *)new FIX::ApplReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplReqID::ApplReqID()\n"
    "    FIX::ApplReqID::ApplReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplReqID *arg1 = (FIX::ApplReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplReqID" "', argument " "1"" of type '" "FIX::ApplReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeFuturesValuationMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeFuturesValuationMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeFuturesValuationMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeFuturesValuationMethod *)new FIX::DerivativeFuturesValuationMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeFuturesValuationMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeFuturesValuationMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeFuturesValuationMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeFuturesValuationMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeFuturesValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeFuturesValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeFuturesValuationMethod *)new FIX::DerivativeFuturesValuationMethod((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeFuturesValuationMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeFuturesValuationMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeFuturesValuationMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeFuturesValuationMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeFuturesValuationMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeFuturesValuationMethod::DerivativeFuturesValuationMethod()\n"
    "    FIX::DerivativeFuturesValuationMethod::DerivativeFuturesValuationMethod(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeFuturesValuationMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeFuturesValuationMethod *arg1 = (FIX::DerivativeFuturesValuationMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeFuturesValuationMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeFuturesValuationMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeFuturesValuationMethod" "', argument " "1"" of type '" "FIX::DerivativeFuturesValuationMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeFuturesValuationMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoLegSecurityAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoLegSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoLegSecurityAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoLegSecurityAltID *)new FIX::NoLegSecurityAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoLegSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLegSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoLegSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoLegSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoLegSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoLegSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoLegSecurityAltID *)new FIX::NoLegSecurityAltID((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoLegSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLegSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoLegSecurityAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoLegSecurityAltID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoLegSecurityAltID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoLegSecurityAltID::NoLegSecurityAltID()\n"
    "    FIX::NoLegSecurityAltID::NoLegSecurityAltID(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoLegSecurityAltID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoLegSecurityAltID *arg1 = (FIX::NoLegSecurityAltID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoLegSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoLegSecurityAltID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoLegSecurityAltID" "', argument " "1"" of type '" "FIX::NoLegSecurityAltID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoLegSecurityAltID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeSecurityType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSecurityType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityType *)new FIX::DerivativeSecurityType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityType *)new FIX::DerivativeSecurityType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSecurityType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSecurityType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSecurityType::DerivativeSecurityType()\n"
    "    FIX::DerivativeSecurityType::DerivativeSecurityType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSecurityType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityType *arg1 = (FIX::DerivativeSecurityType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSecurityType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSecurityType" "', argument " "1"" of type '" "FIX::DerivativeSecurityType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSecurityType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CollInquiryQualifier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollInquiryQualifier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollInquiryQualifier")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollInquiryQualifier *)new FIX::CollInquiryQualifier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollInquiryQualifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryQualifier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollInquiryQualifier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollInquiryQualifier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollInquiryQualifier" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollInquiryQualifier" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollInquiryQualifier *)new FIX::CollInquiryQualifier((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollInquiryQualifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryQualifier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollInquiryQualifier__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollInquiryQualifier__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollInquiryQualifier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollInquiryQualifier::CollInquiryQualifier()\n"
    "    FIX::CollInquiryQualifier::CollInquiryQualifier(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollInquiryQualifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollInquiryQualifier *arg1 = (FIX::CollInquiryQualifier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollInquiryQualifier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollInquiryQualifier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollInquiryQualifier" "', argument " "1"" of type '" "FIX::CollInquiryQualifier *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollInquiryQualifier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RawData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RawData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RawData")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RawData *)new FIX::RawData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RawData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RawData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RawData",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawData" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RawData" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RawData *)new FIX::RawData((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RawData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawData(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RawData__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RawData__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RawData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RawData::RawData()\n"
    "    FIX::RawData::RawData(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RawData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RawData *arg1 = (FIX::RawData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RawData",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RawData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RawData" "', argument " "1"" of type '" "FIX::RawData *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RawData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CashSettlAgentContactPhone__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashSettlAgentContactPhone *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashSettlAgentContactPhone")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashSettlAgentContactPhone *)new FIX::CashSettlAgentContactPhone();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashSettlAgentContactPhone, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentContactPhone__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashSettlAgentContactPhone *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashSettlAgentContactPhone",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashSettlAgentContactPhone" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashSettlAgentContactPhone" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashSettlAgentContactPhone *)new FIX::CashSettlAgentContactPhone((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashSettlAgentContactPhone, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentContactPhone(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashSettlAgentContactPhone__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashSettlAgentContactPhone__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashSettlAgentContactPhone'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashSettlAgentContactPhone::CashSettlAgentContactPhone()\n"
    "    FIX::CashSettlAgentContactPhone::CashSettlAgentContactPhone(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashSettlAgentContactPhone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashSettlAgentContactPhone *arg1 = (FIX::CashSettlAgentContactPhone *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashSettlAgentContactPhone",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashSettlAgentContactPhone, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashSettlAgentContactPhone" "', argument " "1"" of type '" "FIX::CashSettlAgentContactPhone *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashSettlAgentContactPhone * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CreditRating__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CreditRating *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CreditRating")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CreditRating *)new FIX::CreditRating();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CreditRating, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditRating__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CreditRating *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CreditRating",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CreditRating" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CreditRating" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CreditRating *)new FIX::CreditRating((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CreditRating, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CreditRating(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CreditRating__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CreditRating__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CreditRating'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CreditRating::CreditRating()\n"
    "    FIX::CreditRating::CreditRating(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CreditRating(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CreditRating *arg1 = (FIX::CreditRating *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CreditRating",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CreditRating, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CreditRating" "', argument " "1"" of type '" "FIX::CreditRating *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CreditRating * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ContingencyType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContingencyType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ContingencyType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContingencyType *)new FIX::ContingencyType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContingencyType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContingencyType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContingencyType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContingencyType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContingencyType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContingencyType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContingencyType *)new FIX::ContingencyType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContingencyType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContingencyType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ContingencyType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContingencyType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContingencyType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ContingencyType::ContingencyType()\n"
    "    FIX::ContingencyType::ContingencyType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ContingencyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContingencyType *arg1 = (FIX::ContingencyType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContingencyType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ContingencyType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContingencyType" "', argument " "1"" of type '" "FIX::ContingencyType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ContingencyType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StrikeCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikeCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StrikeCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeCurrency *)new FIX::StrikeCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrikeCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrikeCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeCurrency *)new FIX::StrikeCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StrikeCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikeCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StrikeCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StrikeCurrency::StrikeCurrency()\n"
    "    FIX::StrikeCurrency::StrikeCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StrikeCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikeCurrency *arg1 = (FIX::StrikeCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrikeCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StrikeCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrikeCurrency" "', argument " "1"" of type '" "FIX::StrikeCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StrikeCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradeVolume__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeVolume *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeVolume")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeVolume *)new FIX::TradeVolume();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeVolume, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeVolume__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeVolume *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeVolume",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeVolume" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeVolume" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeVolume *)new FIX::TradeVolume((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeVolume, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeVolume(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeVolume__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeVolume__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeVolume'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeVolume::TradeVolume()\n"
    "    FIX::TradeVolume::TradeVolume(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeVolume *arg1 = (FIX::TradeVolume *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeVolume",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeVolume, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeVolume" "', argument " "1"" of type '" "FIX::TradeVolume *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeVolume * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestampSrc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideTrdRegTimestampSrc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideTrdRegTimestampSrc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTrdRegTimestampSrc *)new FIX::SideTrdRegTimestampSrc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTrdRegTimestampSrc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestampSrc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideTrdRegTimestampSrc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideTrdRegTimestampSrc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideTrdRegTimestampSrc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideTrdRegTimestampSrc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTrdRegTimestampSrc *)new FIX::SideTrdRegTimestampSrc((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTrdRegTimestampSrc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestampSrc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideTrdRegTimestampSrc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideTrdRegTimestampSrc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideTrdRegTimestampSrc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideTrdRegTimestampSrc::SideTrdRegTimestampSrc()\n"
    "    FIX::SideTrdRegTimestampSrc::SideTrdRegTimestampSrc(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideTrdRegTimestampSrc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideTrdRegTimestampSrc *arg1 = (FIX::SideTrdRegTimestampSrc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideTrdRegTimestampSrc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideTrdRegTimestampSrc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideTrdRegTimestampSrc" "', argument " "1"" of type '" "FIX::SideTrdRegTimestampSrc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideTrdRegTimestampSrc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DeliveryDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeliveryDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DeliveryDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeliveryDate *)new FIX::DeliveryDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeliveryDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliveryDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DeliveryDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DeliveryDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeliveryDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeliveryDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeliveryDate *)new FIX::DeliveryDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeliveryDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliveryDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DeliveryDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeliveryDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DeliveryDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DeliveryDate::DeliveryDate()\n"
    "    FIX::DeliveryDate::DeliveryDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DeliveryDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeliveryDate *arg1 = (FIX::DeliveryDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DeliveryDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DeliveryDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeliveryDate" "', argument " "1"" of type '" "FIX::DeliveryDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DeliveryDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EmailType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EmailType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EmailType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EmailType *)new FIX::EmailType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EmailType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EmailType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EmailType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EmailType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EmailType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EmailType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EmailType *)new FIX::EmailType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EmailType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EmailType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EmailType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EmailType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EmailType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EmailType::EmailType()\n"
    "    FIX::EmailType::EmailType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EmailType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EmailType *arg1 = (FIX::EmailType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EmailType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EmailType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EmailType" "', argument " "1"" of type '" "FIX::EmailType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EmailType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedListExecInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedListExecInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedListExecInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedListExecInst *)new FIX::EncodedListExecInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedListExecInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListExecInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedListExecInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedListExecInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedListExecInst" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedListExecInst" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedListExecInst *)new FIX::EncodedListExecInst((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedListExecInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListExecInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedListExecInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedListExecInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedListExecInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedListExecInst::EncodedListExecInst()\n"
    "    FIX::EncodedListExecInst::EncodedListExecInst(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedListExecInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedListExecInst *arg1 = (FIX::EncodedListExecInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedListExecInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedListExecInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedListExecInst" "', argument " "1"" of type '" "FIX::EncodedListExecInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedListExecInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ContraTradeTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContraTradeTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ContraTradeTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContraTradeTime *)new FIX::ContraTradeTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContraTradeTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTradeTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContraTradeTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContraTradeTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContraTradeTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContraTradeTime *)new FIX::ContraTradeTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContraTradeTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTradeTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContraTradeTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContraTradeTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContraTradeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContraTradeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContraTradeTime *)new FIX::ContraTradeTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContraTradeTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTradeTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::ContraTradeTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ContraTradeTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContraTradeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContraTradeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContraTradeTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContraTradeTime *)new FIX::ContraTradeTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContraTradeTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTradeTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ContraTradeTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContraTradeTime__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_ContraTradeTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ContraTradeTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContraTradeTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ContraTradeTime::ContraTradeTime()\n"
    "    FIX::ContraTradeTime::ContraTradeTime(bool)\n"
    "    FIX::ContraTradeTime::ContraTradeTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::ContraTradeTime::ContraTradeTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ContraTradeTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContraTradeTime *arg1 = (FIX::ContraTradeTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContraTradeTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ContraTradeTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContraTradeTime" "', argument " "1"" of type '" "FIX::ContraTradeTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ContraTradeTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MaturityMonthYearIncrement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityMonthYearIncrement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaturityMonthYearIncrement")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityMonthYearIncrement *)new FIX::MaturityMonthYearIncrement();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityMonthYearIncrement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYearIncrement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaturityMonthYearIncrement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaturityMonthYearIncrement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaturityMonthYearIncrement" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaturityMonthYearIncrement" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityMonthYearIncrement *)new FIX::MaturityMonthYearIncrement((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityMonthYearIncrement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYearIncrement(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaturityMonthYearIncrement__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityMonthYearIncrement__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaturityMonthYearIncrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaturityMonthYearIncrement::MaturityMonthYearIncrement()\n"
    "    FIX::MaturityMonthYearIncrement::MaturityMonthYearIncrement(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaturityMonthYearIncrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityMonthYearIncrement *arg1 = (FIX::MaturityMonthYearIncrement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaturityMonthYearIncrement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaturityMonthYearIncrement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaturityMonthYearIncrement" "', argument " "1"" of type '" "FIX::MaturityMonthYearIncrement *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaturityMonthYearIncrement * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RootPartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RootPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RootPartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RootPartyIDSource *)new FIX::RootPartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RootPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RootPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RootPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RootPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RootPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RootPartyIDSource *)new FIX::RootPartyIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RootPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RootPartyIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RootPartyIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RootPartyIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RootPartyIDSource::RootPartyIDSource()\n"
    "    FIX::RootPartyIDSource::RootPartyIDSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RootPartyIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RootPartyIDSource *arg1 = (FIX::RootPartyIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RootPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RootPartyIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RootPartyIDSource" "', argument " "1"" of type '" "FIX::RootPartyIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RootPartyIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingCouponPaymentDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCouponPaymentDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingCouponPaymentDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCouponPaymentDate *)new FIX::UnderlyingCouponPaymentDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCouponPaymentDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCouponPaymentDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingCouponPaymentDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingCouponPaymentDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingCouponPaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingCouponPaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCouponPaymentDate *)new FIX::UnderlyingCouponPaymentDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCouponPaymentDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCouponPaymentDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingCouponPaymentDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCouponPaymentDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingCouponPaymentDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingCouponPaymentDate::UnderlyingCouponPaymentDate()\n"
    "    FIX::UnderlyingCouponPaymentDate::UnderlyingCouponPaymentDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingCouponPaymentDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCouponPaymentDate *arg1 = (FIX::UnderlyingCouponPaymentDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingCouponPaymentDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingCouponPaymentDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingCouponPaymentDate" "', argument " "1"" of type '" "FIX::UnderlyingCouponPaymentDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingCouponPaymentDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BidYield__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidYield *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BidYield")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidYield *)new FIX::BidYield();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidYield, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidYield__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BidYield *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BidYield",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BidYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BidYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidYield *)new FIX::BidYield((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidYield, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidYield(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BidYield__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidYield__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BidYield'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BidYield::BidYield()\n"
    "    FIX::BidYield::BidYield(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BidYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidYield *arg1 = (FIX::BidYield *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BidYield",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BidYield, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BidYield" "', argument " "1"" of type '" "FIX::BidYield *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BidYield * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_IOIQltyInd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIQltyInd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IOIQltyInd")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIQltyInd *)new FIX::IOIQltyInd();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIQltyInd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIQltyInd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IOIQltyInd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IOIQltyInd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOIQltyInd" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IOIQltyInd" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIQltyInd *)new FIX::IOIQltyInd((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIQltyInd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIQltyInd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IOIQltyInd__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIQltyInd__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IOIQltyInd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IOIQltyInd::IOIQltyInd()\n"
    "    FIX::IOIQltyInd::IOIQltyInd(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IOIQltyInd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIQltyInd *arg1 = (FIX::IOIQltyInd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IOIQltyInd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IOIQltyInd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOIQltyInd" "', argument " "1"" of type '" "FIX::IOIQltyInd *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IOIQltyInd * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Issuer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Issuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Issuer")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Issuer *)new FIX::Issuer();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Issuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Issuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Issuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Issuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Issuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Issuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Issuer *)new FIX::Issuer((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Issuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Issuer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Issuer__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Issuer__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Issuer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Issuer::Issuer()\n"
    "    FIX::Issuer::Issuer(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Issuer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Issuer *arg1 = (FIX::Issuer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Issuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Issuer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Issuer" "', argument " "1"" of type '" "FIX::Issuer *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Issuer * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CardNumber__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CardNumber *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CardNumber")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CardNumber *)new FIX::CardNumber();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CardNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardNumber__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CardNumber *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CardNumber",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CardNumber" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CardNumber" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CardNumber *)new FIX::CardNumber((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CardNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardNumber(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CardNumber__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CardNumber__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CardNumber'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CardNumber::CardNumber()\n"
    "    FIX::CardNumber::CardNumber(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CardNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CardNumber *arg1 = (FIX::CardNumber *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CardNumber",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CardNumber, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CardNumber" "', argument " "1"" of type '" "FIX::CardNumber *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CardNumber * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoLegStipulations__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoLegStipulations *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoLegStipulations")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoLegStipulations *)new FIX::NoLegStipulations();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoLegStipulations, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLegStipulations__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoLegStipulations *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoLegStipulations",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoLegStipulations" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoLegStipulations" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoLegStipulations *)new FIX::NoLegStipulations((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoLegStipulations, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLegStipulations(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoLegStipulations__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoLegStipulations__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoLegStipulations'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoLegStipulations::NoLegStipulations()\n"
    "    FIX::NoLegStipulations::NoLegStipulations(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoLegStipulations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoLegStipulations *arg1 = (FIX::NoLegStipulations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoLegStipulations",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoLegStipulations, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoLegStipulations" "', argument " "1"" of type '" "FIX::NoLegStipulations *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoLegStipulations * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegSecurityExchange__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecurityExchange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSecurityExchange")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecurityExchange *)new FIX::LegSecurityExchange();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecurityExchange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityExchange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSecurityExchange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSecurityExchange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecurityExchange *)new FIX::LegSecurityExchange((FIX::EXCHANGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecurityExchange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityExchange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSecurityExchange__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecurityExchange__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSecurityExchange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSecurityExchange::LegSecurityExchange()\n"
    "    FIX::LegSecurityExchange::LegSecurityExchange(FIX::EXCHANGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSecurityExchange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecurityExchange *arg1 = (FIX::LegSecurityExchange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSecurityExchange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSecurityExchange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSecurityExchange" "', argument " "1"" of type '" "FIX::LegSecurityExchange *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSecurityExchange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CashOrderQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashOrderQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashOrderQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashOrderQty *)new FIX::CashOrderQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashOrderQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashOrderQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashOrderQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashOrderQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashOrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashOrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashOrderQty *)new FIX::CashOrderQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashOrderQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashOrderQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashOrderQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashOrderQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashOrderQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashOrderQty::CashOrderQty()\n"
    "    FIX::CashOrderQty::CashOrderQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashOrderQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashOrderQty *arg1 = (FIX::CashOrderQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashOrderQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashOrderQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashOrderQty" "', argument " "1"" of type '" "FIX::CashOrderQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashOrderQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AccruedInterestAmt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AccruedInterestAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AccruedInterestAmt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AccruedInterestAmt *)new FIX::AccruedInterestAmt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AccruedInterestAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AccruedInterestAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AccruedInterestAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AccruedInterestAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AccruedInterestAmt *)new FIX::AccruedInterestAmt((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AccruedInterestAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AccruedInterestAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AccruedInterestAmt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AccruedInterestAmt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AccruedInterestAmt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AccruedInterestAmt::AccruedInterestAmt()\n"
    "    FIX::AccruedInterestAmt::AccruedInterestAmt(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AccruedInterestAmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AccruedInterestAmt *arg1 = (FIX::AccruedInterestAmt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AccruedInterestAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AccruedInterestAmt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AccruedInterestAmt" "', argument " "1"" of type '" "FIX::AccruedInterestAmt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AccruedInterestAmt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDEntrySeller__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntrySeller *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDEntrySeller")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntrySeller *)new FIX::MDEntrySeller();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntrySeller, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntrySeller__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDEntrySeller *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDEntrySeller",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDEntrySeller" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDEntrySeller" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntrySeller *)new FIX::MDEntrySeller((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntrySeller, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntrySeller(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDEntrySeller__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntrySeller__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDEntrySeller'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDEntrySeller::MDEntrySeller()\n"
    "    FIX::MDEntrySeller::MDEntrySeller(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDEntrySeller(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntrySeller *arg1 = (FIX::MDEntrySeller *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDEntrySeller",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDEntrySeller, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDEntrySeller" "', argument " "1"" of type '" "FIX::MDEntrySeller *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDEntrySeller * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegPrice *)new FIX::LegPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegPrice *)new FIX::LegPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegPrice::LegPrice()\n"
    "    FIX::LegPrice::LegPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegPrice *arg1 = (FIX::LegPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegPrice" "', argument " "1"" of type '" "FIX::LegPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DeliverToCompID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeliverToCompID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DeliverToCompID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeliverToCompID *)new FIX::DeliverToCompID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeliverToCompID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliverToCompID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DeliverToCompID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DeliverToCompID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeliverToCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeliverToCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeliverToCompID *)new FIX::DeliverToCompID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeliverToCompID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliverToCompID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DeliverToCompID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeliverToCompID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DeliverToCompID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DeliverToCompID::DeliverToCompID()\n"
    "    FIX::DeliverToCompID::DeliverToCompID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DeliverToCompID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeliverToCompID *arg1 = (FIX::DeliverToCompID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DeliverToCompID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DeliverToCompID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeliverToCompID" "', argument " "1"" of type '" "FIX::DeliverToCompID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DeliverToCompID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TargetLocationID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetLocationID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TargetLocationID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetLocationID *)new FIX::TargetLocationID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetLocationID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetLocationID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TargetLocationID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TargetLocationID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TargetLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TargetLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetLocationID *)new FIX::TargetLocationID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetLocationID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetLocationID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TargetLocationID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetLocationID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TargetLocationID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TargetLocationID::TargetLocationID()\n"
    "    FIX::TargetLocationID::TargetLocationID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TargetLocationID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetLocationID *arg1 = (FIX::TargetLocationID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TargetLocationID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TargetLocationID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TargetLocationID" "', argument " "1"" of type '" "FIX::TargetLocationID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TargetLocationID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OfferForwardPoints2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OfferForwardPoints2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OfferForwardPoints2")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OfferForwardPoints2 *)new FIX::OfferForwardPoints2();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OfferForwardPoints2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferForwardPoints2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OfferForwardPoints2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OfferForwardPoints2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OfferForwardPoints2" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OfferForwardPoints2" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OfferForwardPoints2 *)new FIX::OfferForwardPoints2((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OfferForwardPoints2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferForwardPoints2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OfferForwardPoints2__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OfferForwardPoints2__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OfferForwardPoints2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OfferForwardPoints2::OfferForwardPoints2()\n"
    "    FIX::OfferForwardPoints2::OfferForwardPoints2(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OfferForwardPoints2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OfferForwardPoints2 *arg1 = (FIX::OfferForwardPoints2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OfferForwardPoints2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OfferForwardPoints2, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OfferForwardPoints2" "', argument " "1"" of type '" "FIX::OfferForwardPoints2 *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OfferForwardPoints2 * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RatioQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RatioQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RatioQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RatioQty *)new FIX::RatioQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RatioQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RatioQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RatioQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RatioQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RatioQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RatioQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RatioQty *)new FIX::RatioQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RatioQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RatioQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RatioQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RatioQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RatioQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RatioQty::RatioQty()\n"
    "    FIX::RatioQty::RatioQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RatioQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RatioQty *arg1 = (FIX::RatioQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RatioQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RatioQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RatioQty" "', argument " "1"" of type '" "FIX::RatioQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RatioQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MultiLegRptTypeReq__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MultiLegRptTypeReq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MultiLegRptTypeReq")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MultiLegRptTypeReq *)new FIX::MultiLegRptTypeReq();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MultiLegRptTypeReq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultiLegRptTypeReq__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MultiLegRptTypeReq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MultiLegRptTypeReq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MultiLegRptTypeReq" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MultiLegRptTypeReq" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MultiLegRptTypeReq *)new FIX::MultiLegRptTypeReq((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MultiLegRptTypeReq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultiLegRptTypeReq(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MultiLegRptTypeReq__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MultiLegRptTypeReq__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MultiLegRptTypeReq'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MultiLegRptTypeReq::MultiLegRptTypeReq()\n"
    "    FIX::MultiLegRptTypeReq::MultiLegRptTypeReq(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MultiLegRptTypeReq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MultiLegRptTypeReq *arg1 = (FIX::MultiLegRptTypeReq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MultiLegRptTypeReq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MultiLegRptTypeReq, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MultiLegRptTypeReq" "', argument " "1"" of type '" "FIX::MultiLegRptTypeReq *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MultiLegRptTypeReq * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AllocAccount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocAccount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocAccount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocAccount *)new FIX::AllocAccount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocAccount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAccount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocAccount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocAccount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocAccount" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocAccount" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocAccount *)new FIX::AllocAccount((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocAccount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAccount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocAccount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocAccount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocAccount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocAccount::AllocAccount()\n"
    "    FIX::AllocAccount::AllocAccount(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocAccount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocAccount *arg1 = (FIX::AllocAccount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocAccount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocAccount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocAccount" "', argument " "1"" of type '" "FIX::AllocAccount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocAccount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TotalVolumeTraded__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalVolumeTraded *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotalVolumeTraded")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalVolumeTraded *)new FIX::TotalVolumeTraded();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalVolumeTraded, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalVolumeTraded__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotalVolumeTraded *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotalVolumeTraded",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotalVolumeTraded" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotalVolumeTraded" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalVolumeTraded *)new FIX::TotalVolumeTraded((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalVolumeTraded, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalVolumeTraded(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotalVolumeTraded__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalVolumeTraded__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotalVolumeTraded'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotalVolumeTraded::TotalVolumeTraded()\n"
    "    FIX::TotalVolumeTraded::TotalVolumeTraded(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotalVolumeTraded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalVolumeTraded *arg1 = (FIX::TotalVolumeTraded *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotalVolumeTraded",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotalVolumeTraded, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotalVolumeTraded" "', argument " "1"" of type '" "FIX::TotalVolumeTraded *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotalVolumeTraded * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LinesOfText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LinesOfText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LinesOfText")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LinesOfText *)new FIX::LinesOfText();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LinesOfText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinesOfText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LinesOfText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LinesOfText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinesOfText" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinesOfText" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LinesOfText *)new FIX::LinesOfText((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LinesOfText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LinesOfText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LinesOfText__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LinesOfText__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LinesOfText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LinesOfText::LinesOfText()\n"
    "    FIX::LinesOfText::LinesOfText(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LinesOfText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LinesOfText *arg1 = (FIX::LinesOfText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LinesOfText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LinesOfText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinesOfText" "', argument " "1"" of type '" "FIX::LinesOfText *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LinesOfText * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AccountType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AccountType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AccountType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AccountType *)new FIX::AccountType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AccountType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AccountType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AccountType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AccountType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AccountType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AccountType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AccountType *)new FIX::AccountType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AccountType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AccountType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AccountType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AccountType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AccountType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AccountType::AccountType()\n"
    "    FIX::AccountType::AccountType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AccountType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AccountType *arg1 = (FIX::AccountType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AccountType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AccountType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AccountType" "', argument " "1"" of type '" "FIX::AccountType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AccountType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDEntryPositionNo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryPositionNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDEntryPositionNo")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryPositionNo *)new FIX::MDEntryPositionNo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryPositionNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryPositionNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDEntryPositionNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDEntryPositionNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDEntryPositionNo" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDEntryPositionNo" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryPositionNo *)new FIX::MDEntryPositionNo((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryPositionNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryPositionNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDEntryPositionNo__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryPositionNo__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDEntryPositionNo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDEntryPositionNo::MDEntryPositionNo()\n"
    "    FIX::MDEntryPositionNo::MDEntryPositionNo(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDEntryPositionNo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryPositionNo *arg1 = (FIX::MDEntryPositionNo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDEntryPositionNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDEntryPositionNo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDEntryPositionNo" "', argument " "1"" of type '" "FIX::MDEntryPositionNo *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDEntryPositionNo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_HaltReasonInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HaltReasonInt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HaltReasonInt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HaltReasonInt *)new FIX::HaltReasonInt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HaltReasonInt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaltReasonInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::HaltReasonInt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HaltReasonInt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HaltReasonInt" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HaltReasonInt" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HaltReasonInt *)new FIX::HaltReasonInt((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HaltReasonInt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaltReasonInt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_HaltReasonInt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HaltReasonInt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HaltReasonInt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::HaltReasonInt::HaltReasonInt()\n"
    "    FIX::HaltReasonInt::HaltReasonInt(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HaltReasonInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HaltReasonInt *arg1 = (FIX::HaltReasonInt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HaltReasonInt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__HaltReasonInt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HaltReasonInt" "', argument " "1"" of type '" "FIX::HaltReasonInt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::HaltReasonInt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FutSettDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FutSettDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FutSettDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FutSettDate *)new FIX::FutSettDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FutSettDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FutSettDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FutSettDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FutSettDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FutSettDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FutSettDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FutSettDate *)new FIX::FutSettDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FutSettDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FutSettDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FutSettDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FutSettDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FutSettDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FutSettDate::FutSettDate()\n"
    "    FIX::FutSettDate::FutSettDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FutSettDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FutSettDate *arg1 = (FIX::FutSettDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FutSettDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FutSettDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FutSettDate" "', argument " "1"" of type '" "FIX::FutSettDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FutSettDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityDesc *)new FIX::SecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityDesc *)new FIX::SecurityDesc((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityDesc::SecurityDesc()\n"
    "    FIX::SecurityDesc::SecurityDesc(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityDesc *arg1 = (FIX::SecurityDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityDesc" "', argument " "1"" of type '" "FIX::SecurityDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MinQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MinQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MinQty *)new FIX::MinQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MinQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MinQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MinQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MinQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MinQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MinQty *)new FIX::MinQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MinQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MinQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MinQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MinQty::MinQty()\n"
    "    FIX::MinQty::MinQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MinQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinQty *arg1 = (FIX::MinQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MinQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MinQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MinQty" "', argument " "1"" of type '" "FIX::MinQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MinQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlCurrency *)new FIX::SettlCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlCurrency *)new FIX::SettlCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlCurrency::SettlCurrency()\n"
    "    FIX::SettlCurrency::SettlCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlCurrency *arg1 = (FIX::SettlCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlCurrency" "', argument " "1"" of type '" "FIX::SettlCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PegOffsetValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegOffsetValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PegOffsetValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegOffsetValue *)new FIX::PegOffsetValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegOffsetValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegOffsetValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PegOffsetValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PegOffsetValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PegOffsetValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PegOffsetValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegOffsetValue *)new FIX::PegOffsetValue((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegOffsetValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegOffsetValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PegOffsetValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegOffsetValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PegOffsetValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PegOffsetValue::PegOffsetValue()\n"
    "    FIX::PegOffsetValue::PegOffsetValue(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PegOffsetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegOffsetValue *arg1 = (FIX::PegOffsetValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PegOffsetValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PegOffsetValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PegOffsetValue" "', argument " "1"" of type '" "FIX::PegOffsetValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PegOffsetValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeSecurityAltIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityAltIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSecurityAltIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityAltIDSource *)new FIX::DerivativeSecurityAltIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityAltIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityAltIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSecurityAltIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSecurityAltIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityAltIDSource *)new FIX::DerivativeSecurityAltIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityAltIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityAltIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSecurityAltIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityAltIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSecurityAltIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSecurityAltIDSource::DerivativeSecurityAltIDSource()\n"
    "    FIX::DerivativeSecurityAltIDSource::DerivativeSecurityAltIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSecurityAltIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityAltIDSource *arg1 = (FIX::DerivativeSecurityAltIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSecurityAltIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSecurityAltIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSecurityAltIDSource" "', argument " "1"" of type '" "FIX::DerivativeSecurityAltIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSecurityAltIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoSettlPartySubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSettlPartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoSettlPartySubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSettlPartySubIDs *)new FIX::NoSettlPartySubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSettlPartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoSettlPartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoSettlPartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoSettlPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoSettlPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSettlPartySubIDs *)new FIX::NoSettlPartySubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSettlPartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoSettlPartySubIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSettlPartySubIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoSettlPartySubIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoSettlPartySubIDs::NoSettlPartySubIDs()\n"
    "    FIX::NoSettlPartySubIDs::NoSettlPartySubIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoSettlPartySubIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSettlPartySubIDs *arg1 = (FIX::NoSettlPartySubIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoSettlPartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoSettlPartySubIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoSettlPartySubIDs" "', argument " "1"" of type '" "FIX::NoSettlPartySubIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoSettlPartySubIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AllocReportID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocReportID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocReportID *)new FIX::AllocReportID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocReportID *)new FIX::AllocReportID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocReportID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocReportID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocReportID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocReportID::AllocReportID()\n"
    "    FIX::AllocReportID::AllocReportID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocReportID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocReportID *arg1 = (FIX::AllocReportID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocReportID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocReportID" "', argument " "1"" of type '" "FIX::AllocReportID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocReportID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegCFICode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCFICode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegCFICode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCFICode *)new FIX::LegCFICode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCFICode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCFICode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegCFICode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegCFICode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCFICode *)new FIX::LegCFICode((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCFICode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCFICode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegCFICode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCFICode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegCFICode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegCFICode::LegCFICode()\n"
    "    FIX::LegCFICode::LegCFICode(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegCFICode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCFICode *arg1 = (FIX::LegCFICode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegCFICode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegCFICode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegCFICode" "', argument " "1"" of type '" "FIX::LegCFICode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegCFICode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegFutSettDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegFutSettDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegFutSettDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegFutSettDate *)new FIX::LegFutSettDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegFutSettDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegFutSettDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegFutSettDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegFutSettDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegFutSettDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegFutSettDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegFutSettDate *)new FIX::LegFutSettDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegFutSettDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegFutSettDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegFutSettDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegFutSettDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegFutSettDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegFutSettDate::LegFutSettDate()\n"
    "    FIX::LegFutSettDate::LegFutSettDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegFutSettDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegFutSettDate *arg1 = (FIX::LegFutSettDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegFutSettDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegFutSettDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegFutSettDate" "', argument " "1"" of type '" "FIX::LegFutSettDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegFutSettDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurveName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegBenchmarkCurveName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegBenchmarkCurveName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegBenchmarkCurveName *)new FIX::LegBenchmarkCurveName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegBenchmarkCurveName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurveName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegBenchmarkCurveName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegBenchmarkCurveName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegBenchmarkCurveName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegBenchmarkCurveName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegBenchmarkCurveName *)new FIX::LegBenchmarkCurveName((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegBenchmarkCurveName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurveName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegBenchmarkCurveName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegBenchmarkCurveName__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegBenchmarkCurveName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegBenchmarkCurveName::LegBenchmarkCurveName()\n"
    "    FIX::LegBenchmarkCurveName::LegBenchmarkCurveName(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegBenchmarkCurveName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegBenchmarkCurveName *arg1 = (FIX::LegBenchmarkCurveName *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegBenchmarkCurveName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegBenchmarkCurveName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegBenchmarkCurveName" "', argument " "1"" of type '" "FIX::LegBenchmarkCurveName *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegBenchmarkCurveName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ClearingFeeIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClearingFeeIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ClearingFeeIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClearingFeeIndicator *)new FIX::ClearingFeeIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClearingFeeIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingFeeIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ClearingFeeIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ClearingFeeIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClearingFeeIndicator" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ClearingFeeIndicator" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClearingFeeIndicator *)new FIX::ClearingFeeIndicator((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClearingFeeIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingFeeIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ClearingFeeIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClearingFeeIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ClearingFeeIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ClearingFeeIndicator::ClearingFeeIndicator()\n"
    "    FIX::ClearingFeeIndicator::ClearingFeeIndicator(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ClearingFeeIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClearingFeeIndicator *arg1 = (FIX::ClearingFeeIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ClearingFeeIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ClearingFeeIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClearingFeeIndicator" "', argument " "1"" of type '" "FIX::ClearingFeeIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ClearingFeeIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BrokerOfCredit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BrokerOfCredit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BrokerOfCredit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BrokerOfCredit *)new FIX::BrokerOfCredit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BrokerOfCredit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BrokerOfCredit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BrokerOfCredit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BrokerOfCredit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BrokerOfCredit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BrokerOfCredit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BrokerOfCredit *)new FIX::BrokerOfCredit((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BrokerOfCredit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BrokerOfCredit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BrokerOfCredit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BrokerOfCredit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BrokerOfCredit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BrokerOfCredit::BrokerOfCredit()\n"
    "    FIX::BrokerOfCredit::BrokerOfCredit(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BrokerOfCredit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BrokerOfCredit *arg1 = (FIX::BrokerOfCredit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BrokerOfCredit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BrokerOfCredit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BrokerOfCredit" "', argument " "1"" of type '" "FIX::BrokerOfCredit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BrokerOfCredit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecurityListRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityListRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityListRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityListRefID *)new FIX::SecurityListRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityListRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityListRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityListRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityListRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityListRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityListRefID *)new FIX::SecurityListRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityListRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityListRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityListRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityListRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityListRefID::SecurityListRefID()\n"
    "    FIX::SecurityListRefID::SecurityListRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityListRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityListRefID *arg1 = (FIX::SecurityListRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityListRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityListRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityListRefID" "', argument " "1"" of type '" "FIX::SecurityListRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityListRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegMaturityTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegMaturityTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegMaturityTime *)new FIX::UnderlyingLegMaturityTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegMaturityTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTIMEONLY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegMaturityTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegMaturityTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__TZTIMEONLY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMEONLY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegMaturityTime *)new FIX::UnderlyingLegMaturityTime((FIX::TZTIMEONLY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegMaturityTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegMaturityTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__TZTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegMaturityTime__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegMaturityTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegMaturityTime::UnderlyingLegMaturityTime()\n"
    "    FIX::UnderlyingLegMaturityTime::UnderlyingLegMaturityTime(FIX::TZTIMEONLY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegMaturityTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegMaturityTime *arg1 = (FIX::UnderlyingLegMaturityTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegMaturityTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegMaturityTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegMaturityTime" "', argument " "1"" of type '" "FIX::UnderlyingLegMaturityTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegMaturityTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NestedPartySubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NestedPartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NestedPartySubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NestedPartySubIDType *)new FIX::NestedPartySubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NestedPartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NestedPartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NestedPartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NestedPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NestedPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NestedPartySubIDType *)new FIX::NestedPartySubIDType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NestedPartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NestedPartySubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NestedPartySubIDType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NestedPartySubIDType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NestedPartySubIDType::NestedPartySubIDType()\n"
    "    FIX::NestedPartySubIDType::NestedPartySubIDType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NestedPartySubIDType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NestedPartySubIDType *arg1 = (FIX::NestedPartySubIDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NestedPartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NestedPartySubIDType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NestedPartySubIDType" "', argument " "1"" of type '" "FIX::NestedPartySubIDType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NestedPartySubIDType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BidType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BidType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidType *)new FIX::BidType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BidType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BidType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BidType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BidType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidType *)new FIX::BidType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BidType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BidType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BidType::BidType()\n"
    "    FIX::BidType::BidType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BidType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidType *arg1 = (FIX::BidType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BidType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BidType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BidType" "', argument " "1"" of type '" "FIX::BidType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BidType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDEntryRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDEntryRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryRefID *)new FIX::MDEntryRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDEntryRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDEntryRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDEntryRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDEntryRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryRefID *)new FIX::MDEntryRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDEntryRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDEntryRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDEntryRefID::MDEntryRefID()\n"
    "    FIX::MDEntryRefID::MDEntryRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDEntryRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryRefID *arg1 = (FIX::MDEntryRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDEntryRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDEntryRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDEntryRefID" "', argument " "1"" of type '" "FIX::MDEntryRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDEntryRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingUnitOfMeasureQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingUnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingUnitOfMeasureQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingUnitOfMeasureQty *)new FIX::UnderlyingUnitOfMeasureQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingUnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingUnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingUnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingUnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingUnitOfMeasureQty *)new FIX::UnderlyingUnitOfMeasureQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingUnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingUnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingUnitOfMeasureQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingUnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingUnitOfMeasureQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingUnitOfMeasureQty::UnderlyingUnitOfMeasureQty()\n"
    "    FIX::UnderlyingUnitOfMeasureQty::UnderlyingUnitOfMeasureQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingUnitOfMeasureQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingUnitOfMeasureQty *arg1 = (FIX::UnderlyingUnitOfMeasureQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingUnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingUnitOfMeasureQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::UnderlyingUnitOfMeasureQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingUnitOfMeasureQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegMaturityDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegMaturityDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegMaturityDate *)new FIX::UnderlyingLegMaturityDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegMaturityDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegMaturityDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegMaturityDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegMaturityDate *)new FIX::UnderlyingLegMaturityDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegMaturityDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegMaturityDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegMaturityDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegMaturityDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegMaturityDate::UnderlyingLegMaturityDate()\n"
    "    FIX::UnderlyingLegMaturityDate::UnderlyingLegMaturityDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegMaturityDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegMaturityDate *arg1 = (FIX::UnderlyingLegMaturityDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegMaturityDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegMaturityDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegMaturityDate" "', argument " "1"" of type '" "FIX::UnderlyingLegMaturityDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegMaturityDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StartTickPriceRange__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StartTickPriceRange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StartTickPriceRange")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StartTickPriceRange *)new FIX::StartTickPriceRange();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StartTickPriceRange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartTickPriceRange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StartTickPriceRange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StartTickPriceRange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StartTickPriceRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StartTickPriceRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StartTickPriceRange *)new FIX::StartTickPriceRange((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StartTickPriceRange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartTickPriceRange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StartTickPriceRange__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StartTickPriceRange__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StartTickPriceRange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StartTickPriceRange::StartTickPriceRange()\n"
    "    FIX::StartTickPriceRange::StartTickPriceRange(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StartTickPriceRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StartTickPriceRange *arg1 = (FIX::StartTickPriceRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StartTickPriceRange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StartTickPriceRange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StartTickPriceRange" "', argument " "1"" of type '" "FIX::StartTickPriceRange *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StartTickPriceRange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegContractSettlMonth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegContractSettlMonth *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegContractSettlMonth")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegContractSettlMonth *)new FIX::LegContractSettlMonth();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegContractSettlMonth, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegContractSettlMonth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegContractSettlMonth *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegContractSettlMonth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegContractSettlMonth" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegContractSettlMonth" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegContractSettlMonth *)new FIX::LegContractSettlMonth((FIX::MONTHYEAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegContractSettlMonth, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegContractSettlMonth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegContractSettlMonth__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegContractSettlMonth__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegContractSettlMonth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegContractSettlMonth::LegContractSettlMonth()\n"
    "    FIX::LegContractSettlMonth::LegContractSettlMonth(FIX::MONTHYEAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegContractSettlMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegContractSettlMonth *arg1 = (FIX::LegContractSettlMonth *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegContractSettlMonth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegContractSettlMonth, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegContractSettlMonth" "', argument " "1"" of type '" "FIX::LegContractSettlMonth *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegContractSettlMonth * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecurityDesc *)new FIX::UnderlyingSecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecurityDesc *)new FIX::UnderlyingSecurityDesc((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSecurityDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecurityDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSecurityDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSecurityDesc::UnderlyingSecurityDesc()\n"
    "    FIX::UnderlyingSecurityDesc::UnderlyingSecurityDesc(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSecurityDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecurityDesc *arg1 = (FIX::UnderlyingSecurityDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSecurityDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSecurityDesc" "', argument " "1"" of type '" "FIX::UnderlyingSecurityDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSecurityDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CashDistribPayRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashDistribPayRef *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashDistribPayRef")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashDistribPayRef *)new FIX::CashDistribPayRef();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashDistribPayRef, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribPayRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashDistribPayRef *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashDistribPayRef",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashDistribPayRef" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashDistribPayRef" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashDistribPayRef *)new FIX::CashDistribPayRef((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashDistribPayRef, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribPayRef(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashDistribPayRef__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashDistribPayRef__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashDistribPayRef'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashDistribPayRef::CashDistribPayRef()\n"
    "    FIX::CashDistribPayRef::CashDistribPayRef(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashDistribPayRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashDistribPayRef *arg1 = (FIX::CashDistribPayRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashDistribPayRef",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashDistribPayRef, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashDistribPayRef" "', argument " "1"" of type '" "FIX::CashDistribPayRef *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashDistribPayRef * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_QuotePriceType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuotePriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuotePriceType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuotePriceType *)new FIX::QuotePriceType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuotePriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuotePriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuotePriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuotePriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuotePriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuotePriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuotePriceType *)new FIX::QuotePriceType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuotePriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuotePriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuotePriceType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuotePriceType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuotePriceType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuotePriceType::QuotePriceType()\n"
    "    FIX::QuotePriceType::QuotePriceType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuotePriceType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuotePriceType *arg1 = (FIX::QuotePriceType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuotePriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuotePriceType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuotePriceType" "', argument " "1"" of type '" "FIX::QuotePriceType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuotePriceType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedAllocText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedAllocText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedAllocText")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedAllocText *)new FIX::EncodedAllocText();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedAllocText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedAllocText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedAllocText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedAllocText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedAllocText" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedAllocText" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedAllocText *)new FIX::EncodedAllocText((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedAllocText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedAllocText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedAllocText__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedAllocText__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedAllocText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedAllocText::EncodedAllocText()\n"
    "    FIX::EncodedAllocText::EncodedAllocText(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedAllocText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedAllocText *arg1 = (FIX::EncodedAllocText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedAllocText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedAllocText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedAllocText" "', argument " "1"" of type '" "FIX::EncodedAllocText *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedAllocText * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityMonthYear__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingMaturityMonthYear *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingMaturityMonthYear")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingMaturityMonthYear *)new FIX::UnderlyingMaturityMonthYear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingMaturityMonthYear *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingMaturityMonthYear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingMaturityMonthYear *)new FIX::UnderlyingMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingMaturityMonthYear__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingMaturityMonthYear__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingMaturityMonthYear'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingMaturityMonthYear::UnderlyingMaturityMonthYear()\n"
    "    FIX::UnderlyingMaturityMonthYear::UnderlyingMaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingMaturityMonthYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingMaturityMonthYear *arg1 = (FIX::UnderlyingMaturityMonthYear *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingMaturityMonthYear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingMaturityMonthYear, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingMaturityMonthYear" "', argument " "1"" of type '" "FIX::UnderlyingMaturityMonthYear *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingMaturityMonthYear * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingOriginalNotionalPercentageOutstanding__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingOriginalNotionalPercentageOutstanding *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingOriginalNotionalPercentageOutstanding")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingOriginalNotionalPercentageOutstanding *)new FIX::UnderlyingOriginalNotionalPercentageOutstanding();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingOriginalNotionalPercentageOutstanding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingOriginalNotionalPercentageOutstanding__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingOriginalNotionalPercentageOutstanding *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingOriginalNotionalPercentageOutstanding",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingOriginalNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingOriginalNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingOriginalNotionalPercentageOutstanding *)new FIX::UnderlyingOriginalNotionalPercentageOutstanding((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingOriginalNotionalPercentageOutstanding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingOriginalNotionalPercentageOutstanding(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingOriginalNotionalPercentageOutstanding__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingOriginalNotionalPercentageOutstanding__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingOriginalNotionalPercentageOutstanding'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingOriginalNotionalPercentageOutstanding::UnderlyingOriginalNotionalPercentageOutstanding()\n"
    "    FIX::UnderlyingOriginalNotionalPercentageOutstanding::UnderlyingOriginalNotionalPercentageOutstanding(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingOriginalNotionalPercentageOutstanding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingOriginalNotionalPercentageOutstanding *arg1 = (FIX::UnderlyingOriginalNotionalPercentageOutstanding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingOriginalNotionalPercentageOutstanding",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingOriginalNotionalPercentageOutstanding, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingOriginalNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::UnderlyingOriginalNotionalPercentageOutstanding *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingOriginalNotionalPercentageOutstanding * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MultilegPriceMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MultilegPriceMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MultilegPriceMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MultilegPriceMethod *)new FIX::MultilegPriceMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MultilegPriceMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultilegPriceMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MultilegPriceMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MultilegPriceMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MultilegPriceMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MultilegPriceMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MultilegPriceMethod *)new FIX::MultilegPriceMethod((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MultilegPriceMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultilegPriceMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MultilegPriceMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MultilegPriceMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MultilegPriceMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MultilegPriceMethod::MultilegPriceMethod()\n"
    "    FIX::MultilegPriceMethod::MultilegPriceMethod(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MultilegPriceMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MultilegPriceMethod *arg1 = (FIX::MultilegPriceMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MultilegPriceMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MultilegPriceMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MultilegPriceMethod" "', argument " "1"" of type '" "FIX::MultilegPriceMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MultilegPriceMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TotNoFills__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoFills *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotNoFills")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoFills *)new FIX::TotNoFills();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoFills, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoFills__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotNoFills *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotNoFills",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotNoFills" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotNoFills" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoFills *)new FIX::TotNoFills((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoFills, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoFills(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotNoFills__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoFills__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotNoFills'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotNoFills::TotNoFills()\n"
    "    FIX::TotNoFills::TotNoFills(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotNoFills(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoFills *arg1 = (FIX::TotNoFills *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotNoFills",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotNoFills, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotNoFills" "', argument " "1"" of type '" "FIX::TotNoFills *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotNoFills * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeSettleOnOpenFlag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSettleOnOpenFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSettleOnOpenFlag")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSettleOnOpenFlag *)new FIX::DerivativeSettleOnOpenFlag();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSettleOnOpenFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSettleOnOpenFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSettleOnOpenFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSettleOnOpenFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSettleOnOpenFlag" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSettleOnOpenFlag" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSettleOnOpenFlag *)new FIX::DerivativeSettleOnOpenFlag((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSettleOnOpenFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSettleOnOpenFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSettleOnOpenFlag__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSettleOnOpenFlag__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSettleOnOpenFlag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSettleOnOpenFlag::DerivativeSettleOnOpenFlag()\n"
    "    FIX::DerivativeSettleOnOpenFlag::DerivativeSettleOnOpenFlag(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSettleOnOpenFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSettleOnOpenFlag *arg1 = (FIX::DerivativeSettleOnOpenFlag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSettleOnOpenFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSettleOnOpenFlag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSettleOnOpenFlag" "', argument " "1"" of type '" "FIX::DerivativeSettleOnOpenFlag *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSettleOnOpenFlag * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingRepurchaseTerm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingRepurchaseTerm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingRepurchaseTerm")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingRepurchaseTerm *)new FIX::UnderlyingRepurchaseTerm();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingRepurchaseTerm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRepurchaseTerm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingRepurchaseTerm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingRepurchaseTerm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingRepurchaseTerm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingRepurchaseTerm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingRepurchaseTerm *)new FIX::UnderlyingRepurchaseTerm((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingRepurchaseTerm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRepurchaseTerm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingRepurchaseTerm__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingRepurchaseTerm__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingRepurchaseTerm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingRepurchaseTerm::UnderlyingRepurchaseTerm()\n"
    "    FIX::UnderlyingRepurchaseTerm::UnderlyingRepurchaseTerm(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingRepurchaseTerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingRepurchaseTerm *arg1 = (FIX::UnderlyingRepurchaseTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingRepurchaseTerm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingRepurchaseTerm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingRepurchaseTerm" "', argument " "1"" of type '" "FIX::UnderlyingRepurchaseTerm *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingRepurchaseTerm * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeCountryOfIssue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeCountryOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeCountryOfIssue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeCountryOfIssue *)new FIX::DerivativeCountryOfIssue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeCountryOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeCountryOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::COUNTRY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeCountryOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeCountryOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__COUNTRY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeCountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeCountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::COUNTRY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeCountryOfIssue *)new FIX::DerivativeCountryOfIssue((FIX::COUNTRY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeCountryOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeCountryOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeCountryOfIssue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__COUNTRY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeCountryOfIssue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeCountryOfIssue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeCountryOfIssue::DerivativeCountryOfIssue()\n"
    "    FIX::DerivativeCountryOfIssue::DerivativeCountryOfIssue(FIX::COUNTRY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeCountryOfIssue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeCountryOfIssue *arg1 = (FIX::DerivativeCountryOfIssue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeCountryOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeCountryOfIssue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeCountryOfIssue" "', argument " "1"" of type '" "FIX::DerivativeCountryOfIssue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeCountryOfIssue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ListMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ListMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListMethod *)new FIX::ListMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ListMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ListMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListMethod *)new FIX::ListMethod((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ListMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ListMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ListMethod::ListMethod()\n"
    "    FIX::ListMethod::ListMethod(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListMethod *arg1 = (FIX::ListMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ListMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ListMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListMethod" "', argument " "1"" of type '" "FIX::ListMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ListMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingCPProgram__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCPProgram *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingCPProgram")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCPProgram *)new FIX::UnderlyingCPProgram();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCPProgram, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCPProgram__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingCPProgram *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingCPProgram",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingCPProgram" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingCPProgram" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCPProgram *)new FIX::UnderlyingCPProgram((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCPProgram, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCPProgram(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingCPProgram__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCPProgram__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingCPProgram'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingCPProgram::UnderlyingCPProgram()\n"
    "    FIX::UnderlyingCPProgram::UnderlyingCPProgram(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingCPProgram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCPProgram *arg1 = (FIX::UnderlyingCPProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingCPProgram",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingCPProgram, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingCPProgram" "', argument " "1"" of type '" "FIX::UnderlyingCPProgram *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingCPProgram * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PriceDelta__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceDelta *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PriceDelta")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceDelta *)new FIX::PriceDelta();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceDelta, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceDelta__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PriceDelta *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PriceDelta",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PriceDelta" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PriceDelta" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceDelta *)new FIX::PriceDelta((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceDelta, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceDelta(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PriceDelta__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceDelta__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PriceDelta'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PriceDelta::PriceDelta()\n"
    "    FIX::PriceDelta::PriceDelta(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PriceDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceDelta *arg1 = (FIX::PriceDelta *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PriceDelta",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PriceDelta, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PriceDelta" "', argument " "1"" of type '" "FIX::PriceDelta *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PriceDelta * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RefSeqNum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefSeqNum")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefSeqNum *)new FIX::RefSeqNum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SEQNUM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefSeqNum *)new FIX::RefSeqNum((FIX::SEQNUM const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefSeqNum__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefSeqNum__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefSeqNum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefSeqNum::RefSeqNum()\n"
    "    FIX::RefSeqNum::RefSeqNum(FIX::SEQNUM const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefSeqNum *arg1 = (FIX::RefSeqNum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefSeqNum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefSeqNum" "', argument " "1"" of type '" "FIX::RefSeqNum *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefSeqNum * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AutoAcceptIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AutoAcceptIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AutoAcceptIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AutoAcceptIndicator *)new FIX::AutoAcceptIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AutoAcceptIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AutoAcceptIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AutoAcceptIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AutoAcceptIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AutoAcceptIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AutoAcceptIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AutoAcceptIndicator *)new FIX::AutoAcceptIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AutoAcceptIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AutoAcceptIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AutoAcceptIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AutoAcceptIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AutoAcceptIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AutoAcceptIndicator::AutoAcceptIndicator()\n"
    "    FIX::AutoAcceptIndicator::AutoAcceptIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AutoAcceptIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AutoAcceptIndicator *arg1 = (FIX::AutoAcceptIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AutoAcceptIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AutoAcceptIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AutoAcceptIndicator" "', argument " "1"" of type '" "FIX::AutoAcceptIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AutoAcceptIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDImplicitDelete__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDImplicitDelete *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDImplicitDelete")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDImplicitDelete *)new FIX::MDImplicitDelete();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDImplicitDelete, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDImplicitDelete__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDImplicitDelete *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDImplicitDelete",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDImplicitDelete" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDImplicitDelete" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDImplicitDelete *)new FIX::MDImplicitDelete((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDImplicitDelete, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDImplicitDelete(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDImplicitDelete__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDImplicitDelete__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDImplicitDelete'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDImplicitDelete::MDImplicitDelete()\n"
    "    FIX::MDImplicitDelete::MDImplicitDelete(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDImplicitDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDImplicitDelete *arg1 = (FIX::MDImplicitDelete *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDImplicitDelete",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDImplicitDelete, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDImplicitDelete" "', argument " "1"" of type '" "FIX::MDImplicitDelete *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDImplicitDelete * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoStipulations__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoStipulations *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoStipulations")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoStipulations *)new FIX::NoStipulations();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoStipulations, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStipulations__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoStipulations *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoStipulations",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoStipulations" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoStipulations" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoStipulations *)new FIX::NoStipulations((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoStipulations, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStipulations(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoStipulations__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoStipulations__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoStipulations'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoStipulations::NoStipulations()\n"
    "    FIX::NoStipulations::NoStipulations(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoStipulations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoStipulations *arg1 = (FIX::NoStipulations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoStipulations",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoStipulations, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoStipulations" "', argument " "1"" of type '" "FIX::NoStipulations *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoStipulations * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ClearingBusinessDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClearingBusinessDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ClearingBusinessDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClearingBusinessDate *)new FIX::ClearingBusinessDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClearingBusinessDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingBusinessDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ClearingBusinessDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ClearingBusinessDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClearingBusinessDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ClearingBusinessDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClearingBusinessDate *)new FIX::ClearingBusinessDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClearingBusinessDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingBusinessDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ClearingBusinessDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClearingBusinessDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ClearingBusinessDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ClearingBusinessDate::ClearingBusinessDate()\n"
    "    FIX::ClearingBusinessDate::ClearingBusinessDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ClearingBusinessDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClearingBusinessDate *arg1 = (FIX::ClearingBusinessDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ClearingBusinessDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ClearingBusinessDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClearingBusinessDate" "', argument " "1"" of type '" "FIX::ClearingBusinessDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ClearingBusinessDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LocationID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LocationID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LocationID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LocationID *)new FIX::LocationID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocationID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocationID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LocationID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LocationID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LocationID *)new FIX::LocationID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocationID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocationID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LocationID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocationID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LocationID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LocationID::LocationID()\n"
    "    FIX::LocationID::LocationID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LocationID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LocationID *arg1 = (FIX::LocationID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LocationID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LocationID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocationID" "', argument " "1"" of type '" "FIX::LocationID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LocationID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Currency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Currency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Currency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Currency *)new FIX::Currency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Currency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Currency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Currency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Currency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Currency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Currency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Currency *)new FIX::Currency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Currency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Currency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Currency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Currency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Currency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Currency::Currency()\n"
    "    FIX::Currency::Currency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Currency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Currency *arg1 = (FIX::Currency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Currency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Currency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Currency" "', argument " "1"" of type '" "FIX::Currency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Currency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RoutingType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RoutingType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RoutingType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RoutingType *)new FIX::RoutingType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RoutingType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoutingType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RoutingType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RoutingType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RoutingType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RoutingType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RoutingType *)new FIX::RoutingType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RoutingType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoutingType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RoutingType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RoutingType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RoutingType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RoutingType::RoutingType()\n"
    "    FIX::RoutingType::RoutingType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RoutingType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RoutingType *arg1 = (FIX::RoutingType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RoutingType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RoutingType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RoutingType" "', argument " "1"" of type '" "FIX::RoutingType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RoutingType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingStrikePrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingStrikePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingStrikePrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingStrikePrice *)new FIX::UnderlyingStrikePrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingStrikePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStrikePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingStrikePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingStrikePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingStrikePrice *)new FIX::UnderlyingStrikePrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingStrikePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStrikePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingStrikePrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingStrikePrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingStrikePrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingStrikePrice::UnderlyingStrikePrice()\n"
    "    FIX::UnderlyingStrikePrice::UnderlyingStrikePrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingStrikePrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingStrikePrice *arg1 = (FIX::UnderlyingStrikePrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingStrikePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingStrikePrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingStrikePrice" "', argument " "1"" of type '" "FIX::UnderlyingStrikePrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingStrikePrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BidTradeType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidTradeType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BidTradeType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidTradeType *)new FIX::BidTradeType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidTradeType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidTradeType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BidTradeType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BidTradeType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BidTradeType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BidTradeType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidTradeType *)new FIX::BidTradeType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidTradeType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidTradeType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BidTradeType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidTradeType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BidTradeType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BidTradeType::BidTradeType()\n"
    "    FIX::BidTradeType::BidTradeType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BidTradeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidTradeType *arg1 = (FIX::BidTradeType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BidTradeType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BidTradeType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BidTradeType" "', argument " "1"" of type '" "FIX::BidTradeType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BidTradeType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingAttachmentPoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingAttachmentPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingAttachmentPoint")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingAttachmentPoint *)new FIX::UnderlyingAttachmentPoint();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingAttachmentPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingAttachmentPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingAttachmentPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingAttachmentPoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingAttachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingAttachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingAttachmentPoint *)new FIX::UnderlyingAttachmentPoint((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingAttachmentPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingAttachmentPoint(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingAttachmentPoint__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingAttachmentPoint__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingAttachmentPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingAttachmentPoint::UnderlyingAttachmentPoint()\n"
    "    FIX::UnderlyingAttachmentPoint::UnderlyingAttachmentPoint(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingAttachmentPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingAttachmentPoint *arg1 = (FIX::UnderlyingAttachmentPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingAttachmentPoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingAttachmentPoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingAttachmentPoint" "', argument " "1"" of type '" "FIX::UnderlyingAttachmentPoint *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingAttachmentPoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TotNoRejQuotes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoRejQuotes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotNoRejQuotes")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoRejQuotes *)new FIX::TotNoRejQuotes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoRejQuotes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoRejQuotes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotNoRejQuotes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotNoRejQuotes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotNoRejQuotes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotNoRejQuotes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoRejQuotes *)new FIX::TotNoRejQuotes((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoRejQuotes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoRejQuotes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotNoRejQuotes__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoRejQuotes__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotNoRejQuotes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotNoRejQuotes::TotNoRejQuotes()\n"
    "    FIX::TotNoRejQuotes::TotNoRejQuotes(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotNoRejQuotes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoRejQuotes *arg1 = (FIX::TotNoRejQuotes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotNoRejQuotes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotNoRejQuotes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotNoRejQuotes" "', argument " "1"" of type '" "FIX::TotNoRejQuotes *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotNoRejQuotes * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrdStatusReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrdStatusReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrdStatusReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrdStatusReqID *)new FIX::OrdStatusReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrdStatusReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdStatusReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrdStatusReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrdStatusReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrdStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrdStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrdStatusReqID *)new FIX::OrdStatusReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrdStatusReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdStatusReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrdStatusReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrdStatusReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrdStatusReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrdStatusReqID::OrdStatusReqID()\n"
    "    FIX::OrdStatusReqID::OrdStatusReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrdStatusReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrdStatusReqID *arg1 = (FIX::OrdStatusReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrdStatusReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrdStatusReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrdStatusReqID" "', argument " "1"" of type '" "FIX::OrdStatusReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrdStatusReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SenderCompID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SenderCompID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SenderCompID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SenderCompID *)new FIX::SenderCompID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SenderCompID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SenderCompID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SenderCompID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SenderCompID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SenderCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SenderCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SenderCompID *)new FIX::SenderCompID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SenderCompID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SenderCompID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SenderCompID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SenderCompID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SenderCompID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SenderCompID::SenderCompID()\n"
    "    FIX::SenderCompID::SenderCompID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SenderCompID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SenderCompID *arg1 = (FIX::SenderCompID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SenderCompID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SenderCompID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SenderCompID" "', argument " "1"" of type '" "FIX::SenderCompID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SenderCompID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrdRejReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrdRejReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrdRejReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrdRejReason *)new FIX::OrdRejReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrdRejReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdRejReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrdRejReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrdRejReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrdRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrdRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrdRejReason *)new FIX::OrdRejReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrdRejReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdRejReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrdRejReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrdRejReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrdRejReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrdRejReason::OrdRejReason()\n"
    "    FIX::OrdRejReason::OrdRejReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrdRejReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrdRejReason *arg1 = (FIX::OrdRejReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrdRejReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrdRejReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrdRejReason" "', argument " "1"" of type '" "FIX::OrdRejReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrdRejReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MaturityMonthYearIncrementUnits__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityMonthYearIncrementUnits *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaturityMonthYearIncrementUnits")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityMonthYearIncrementUnits *)new FIX::MaturityMonthYearIncrementUnits();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityMonthYearIncrementUnits, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYearIncrementUnits__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaturityMonthYearIncrementUnits *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaturityMonthYearIncrementUnits",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaturityMonthYearIncrementUnits" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaturityMonthYearIncrementUnits" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityMonthYearIncrementUnits *)new FIX::MaturityMonthYearIncrementUnits((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityMonthYearIncrementUnits, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYearIncrementUnits(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaturityMonthYearIncrementUnits__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityMonthYearIncrementUnits__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaturityMonthYearIncrementUnits'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaturityMonthYearIncrementUnits::MaturityMonthYearIncrementUnits()\n"
    "    FIX::MaturityMonthYearIncrementUnits::MaturityMonthYearIncrementUnits(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaturityMonthYearIncrementUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityMonthYearIncrementUnits *arg1 = (FIX::MaturityMonthYearIncrementUnits *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaturityMonthYearIncrementUnits",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaturityMonthYearIncrementUnits, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaturityMonthYearIncrementUnits" "', argument " "1"" of type '" "FIX::MaturityMonthYearIncrementUnits *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaturityMonthYearIncrementUnits * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DisplayWhen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DisplayWhen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DisplayWhen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DisplayWhen *)new FIX::DisplayWhen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DisplayWhen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayWhen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DisplayWhen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DisplayWhen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DisplayWhen" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DisplayWhen" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DisplayWhen *)new FIX::DisplayWhen((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DisplayWhen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayWhen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DisplayWhen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DisplayWhen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DisplayWhen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DisplayWhen::DisplayWhen()\n"
    "    FIX::DisplayWhen::DisplayWhen(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DisplayWhen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DisplayWhen *arg1 = (FIX::DisplayWhen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DisplayWhen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DisplayWhen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DisplayWhen" "', argument " "1"" of type '" "FIX::DisplayWhen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DisplayWhen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ApplQueueAction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplQueueAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplQueueAction")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplQueueAction *)new FIX::ApplQueueAction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplQueueAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplQueueAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplQueueAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplQueueAction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplQueueAction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplQueueAction *)new FIX::ApplQueueAction((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplQueueAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplQueueAction__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplQueueAction__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplQueueAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplQueueAction::ApplQueueAction()\n"
    "    FIX::ApplQueueAction::ApplQueueAction(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplQueueAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplQueueAction *arg1 = (FIX::ApplQueueAction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplQueueAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplQueueAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplQueueAction" "', argument " "1"" of type '" "FIX::ApplQueueAction *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplQueueAction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RegistTransType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RegistTransType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistTransType *)new FIX::RegistTransType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RegistTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RegistTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegistTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegistTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistTransType *)new FIX::RegistTransType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RegistTransType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistTransType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RegistTransType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RegistTransType::RegistTransType()\n"
    "    FIX::RegistTransType::RegistTransType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RegistTransType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistTransType *arg1 = (FIX::RegistTransType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RegistTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RegistTransType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegistTransType" "', argument " "1"" of type '" "FIX::RegistTransType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RegistTransType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PaymentRemitterID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PaymentRemitterID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PaymentRemitterID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PaymentRemitterID *)new FIX::PaymentRemitterID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PaymentRemitterID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentRemitterID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PaymentRemitterID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PaymentRemitterID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PaymentRemitterID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PaymentRemitterID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PaymentRemitterID *)new FIX::PaymentRemitterID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PaymentRemitterID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentRemitterID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PaymentRemitterID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PaymentRemitterID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PaymentRemitterID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PaymentRemitterID::PaymentRemitterID()\n"
    "    FIX::PaymentRemitterID::PaymentRemitterID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PaymentRemitterID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PaymentRemitterID *arg1 = (FIX::PaymentRemitterID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PaymentRemitterID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PaymentRemitterID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PaymentRemitterID" "', argument " "1"" of type '" "FIX::PaymentRemitterID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PaymentRemitterID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PriceType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PriceType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceType *)new FIX::PriceType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceType *)new FIX::PriceType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PriceType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PriceType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PriceType::PriceType()\n"
    "    FIX::PriceType::PriceType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PriceType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceType *arg1 = (FIX::PriceType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PriceType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PriceType" "', argument " "1"" of type '" "FIX::PriceType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PriceType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MarketReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarketReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MarketReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarketReqID *)new FIX::MarketReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarketReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MarketReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MarketReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarketReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarketReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarketReqID *)new FIX::MarketReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarketReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MarketReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarketReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarketReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MarketReqID::MarketReqID()\n"
    "    FIX::MarketReqID::MarketReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MarketReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarketReqID *arg1 = (FIX::MarketReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MarketReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MarketReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarketReqID" "', argument " "1"" of type '" "FIX::MarketReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MarketReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoNestedInstrAttrib__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNestedInstrAttrib *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoNestedInstrAttrib")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNestedInstrAttrib *)new FIX::NoNestedInstrAttrib();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNestedInstrAttrib, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNestedInstrAttrib__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoNestedInstrAttrib *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoNestedInstrAttrib",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoNestedInstrAttrib" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoNestedInstrAttrib" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNestedInstrAttrib *)new FIX::NoNestedInstrAttrib((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNestedInstrAttrib, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNestedInstrAttrib(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoNestedInstrAttrib__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNestedInstrAttrib__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoNestedInstrAttrib'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoNestedInstrAttrib::NoNestedInstrAttrib()\n"
    "    FIX::NoNestedInstrAttrib::NoNestedInstrAttrib(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoNestedInstrAttrib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNestedInstrAttrib *arg1 = (FIX::NoNestedInstrAttrib *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoNestedInstrAttrib",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoNestedInstrAttrib, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoNestedInstrAttrib" "', argument " "1"" of type '" "FIX::NoNestedInstrAttrib *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoNestedInstrAttrib * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecuritySubType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecuritySubType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecuritySubType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecuritySubType *)new FIX::SecuritySubType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecuritySubType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySubType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecuritySubType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecuritySubType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecuritySubType *)new FIX::SecuritySubType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecuritySubType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySubType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecuritySubType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecuritySubType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecuritySubType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecuritySubType::SecuritySubType()\n"
    "    FIX::SecuritySubType::SecuritySubType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecuritySubType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecuritySubType *arg1 = (FIX::SecuritySubType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecuritySubType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecuritySubType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecuritySubType" "', argument " "1"" of type '" "FIX::SecuritySubType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecuritySubType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ClOrdID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClOrdID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ClOrdID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClOrdID *)new FIX::ClOrdID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClOrdID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClOrdID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ClOrdID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ClOrdID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClOrdID *)new FIX::ClOrdID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClOrdID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClOrdID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ClOrdID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClOrdID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ClOrdID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ClOrdID::ClOrdID()\n"
    "    FIX::ClOrdID::ClOrdID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ClOrdID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClOrdID *arg1 = (FIX::ClOrdID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ClOrdID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ClOrdID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClOrdID" "', argument " "1"" of type '" "FIX::ClOrdID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ClOrdID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MaturityDay__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityDay *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaturityDay")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityDay *)new FIX::MaturityDay();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityDay, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityDay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DAYOFMONTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaturityDay *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaturityDay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DAYOFMONTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaturityDay" "', argument " "1"" of type '" "FIX::DAYOFMONTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaturityDay" "', argument " "1"" of type '" "FIX::DAYOFMONTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DAYOFMONTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityDay *)new FIX::MaturityDay((FIX::DAYOFMONTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityDay, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityDay(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaturityDay__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DAYOFMONTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityDay__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaturityDay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaturityDay::MaturityDay()\n"
    "    FIX::MaturityDay::MaturityDay(FIX::DAYOFMONTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaturityDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityDay *arg1 = (FIX::MaturityDay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaturityDay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaturityDay, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaturityDay" "', argument " "1"" of type '" "FIX::MaturityDay *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaturityDay * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingSeniority__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSeniority *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSeniority")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSeniority *)new FIX::UnderlyingSeniority();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSeniority, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSeniority__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSeniority *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSeniority",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSeniority" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSeniority" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSeniority *)new FIX::UnderlyingSeniority((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSeniority, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSeniority(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSeniority__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSeniority__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSeniority'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSeniority::UnderlyingSeniority()\n"
    "    FIX::UnderlyingSeniority::UnderlyingSeniority(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSeniority(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSeniority *arg1 = (FIX::UnderlyingSeniority *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSeniority",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSeniority, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSeniority" "', argument " "1"" of type '" "FIX::UnderlyingSeniority *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSeniority * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MarketSegmentDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarketSegmentDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MarketSegmentDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarketSegmentDesc *)new FIX::MarketSegmentDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarketSegmentDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketSegmentDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MarketSegmentDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MarketSegmentDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarketSegmentDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarketSegmentDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarketSegmentDesc *)new FIX::MarketSegmentDesc((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarketSegmentDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketSegmentDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MarketSegmentDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarketSegmentDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarketSegmentDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MarketSegmentDesc::MarketSegmentDesc()\n"
    "    FIX::MarketSegmentDesc::MarketSegmentDesc(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MarketSegmentDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarketSegmentDesc *arg1 = (FIX::MarketSegmentDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MarketSegmentDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MarketSegmentDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarketSegmentDesc" "', argument " "1"" of type '" "FIX::MarketSegmentDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MarketSegmentDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoMarketSegments__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMarketSegments *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoMarketSegments")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMarketSegments *)new FIX::NoMarketSegments();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMarketSegments, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMarketSegments__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoMarketSegments *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoMarketSegments",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoMarketSegments" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoMarketSegments" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMarketSegments *)new FIX::NoMarketSegments((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMarketSegments, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMarketSegments(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoMarketSegments__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMarketSegments__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoMarketSegments'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoMarketSegments::NoMarketSegments()\n"
    "    FIX::NoMarketSegments::NoMarketSegments(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoMarketSegments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMarketSegments *arg1 = (FIX::NoMarketSegments *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoMarketSegments",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoMarketSegments, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoMarketSegments" "', argument " "1"" of type '" "FIX::NoMarketSegments *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoMarketSegments * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlObligMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlObligMode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlObligMode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlObligMode *)new FIX::SettlObligMode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlObligMode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlObligMode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlObligMode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlObligMode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlObligMode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlObligMode *)new FIX::SettlObligMode((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlObligMode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligMode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlObligMode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlObligMode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlObligMode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlObligMode::SettlObligMode()\n"
    "    FIX::SettlObligMode::SettlObligMode(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlObligMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlObligMode *arg1 = (FIX::SettlObligMode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlObligMode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlObligMode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlObligMode" "', argument " "1"" of type '" "FIX::SettlObligMode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlObligMode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecurityUpdateAction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityUpdateAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityUpdateAction")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityUpdateAction *)new FIX::SecurityUpdateAction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityUpdateAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityUpdateAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityUpdateAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityUpdateAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityUpdateAction *)new FIX::SecurityUpdateAction((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityUpdateAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityUpdateAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityUpdateAction__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityUpdateAction__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityUpdateAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityUpdateAction::SecurityUpdateAction()\n"
    "    FIX::SecurityUpdateAction::SecurityUpdateAction(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityUpdateAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityUpdateAction *arg1 = (FIX::SecurityUpdateAction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityUpdateAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityUpdateAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityUpdateAction" "', argument " "1"" of type '" "FIX::SecurityUpdateAction *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityUpdateAction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NetworkRequestType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NetworkRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NetworkRequestType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NetworkRequestType *)new FIX::NetworkRequestType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NetworkRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NetworkRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NetworkRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NetworkRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NetworkRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NetworkRequestType *)new FIX::NetworkRequestType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NetworkRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NetworkRequestType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NetworkRequestType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NetworkRequestType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NetworkRequestType::NetworkRequestType()\n"
    "    FIX::NetworkRequestType::NetworkRequestType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NetworkRequestType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NetworkRequestType *arg1 = (FIX::NetworkRequestType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NetworkRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NetworkRequestType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NetworkRequestType" "', argument " "1"" of type '" "FIX::NetworkRequestType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NetworkRequestType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LiquidityPctLow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LiquidityPctLow *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LiquidityPctLow")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LiquidityPctLow *)new FIX::LiquidityPctLow();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LiquidityPctLow, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityPctLow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LiquidityPctLow *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LiquidityPctLow",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LiquidityPctLow" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LiquidityPctLow" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LiquidityPctLow *)new FIX::LiquidityPctLow((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LiquidityPctLow, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityPctLow(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LiquidityPctLow__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LiquidityPctLow__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LiquidityPctLow'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LiquidityPctLow::LiquidityPctLow()\n"
    "    FIX::LiquidityPctLow::LiquidityPctLow(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LiquidityPctLow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LiquidityPctLow *arg1 = (FIX::LiquidityPctLow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LiquidityPctLow",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LiquidityPctLow, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LiquidityPctLow" "', argument " "1"" of type '" "FIX::LiquidityPctLow *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LiquidityPctLow * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyRole *)new FIX::PartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyRole *)new FIX::PartyRole((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartyRole__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PartyRole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PartyRole::PartyRole()\n"
    "    FIX::PartyRole::PartyRole(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PartyRole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyRole *arg1 = (FIX::PartyRole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PartyRole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PartyRole" "', argument " "1"" of type '" "FIX::PartyRole *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PartyRole * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegRatioQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegRatioQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegRatioQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegRatioQty *)new FIX::LegRatioQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegRatioQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRatioQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegRatioQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegRatioQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegRatioQty" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegRatioQty" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegRatioQty *)new FIX::LegRatioQty((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegRatioQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRatioQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegRatioQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegRatioQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegRatioQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegRatioQty::LegRatioQty()\n"
    "    FIX::LegRatioQty::LegRatioQty(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegRatioQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegRatioQty *arg1 = (FIX::LegRatioQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegRatioQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegRatioQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegRatioQty" "', argument " "1"" of type '" "FIX::LegRatioQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegRatioQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlCurrFxRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlCurrFxRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlCurrFxRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlCurrFxRate *)new FIX::SettlCurrFxRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlCurrFxRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrFxRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlCurrFxRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlCurrFxRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlCurrFxRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlCurrFxRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlCurrFxRate *)new FIX::SettlCurrFxRate((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlCurrFxRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrFxRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlCurrFxRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlCurrFxRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlCurrFxRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlCurrFxRate::SettlCurrFxRate()\n"
    "    FIX::SettlCurrFxRate::SettlCurrFxRate(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlCurrFxRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlCurrFxRate *arg1 = (FIX::SettlCurrFxRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlCurrFxRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlCurrFxRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlCurrFxRate" "', argument " "1"" of type '" "FIX::SettlCurrFxRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlCurrFxRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegContractMultiplierUnit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegContractMultiplierUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegContractMultiplierUnit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegContractMultiplierUnit *)new FIX::LegContractMultiplierUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegContractMultiplierUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegContractMultiplierUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegContractMultiplierUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegContractMultiplierUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegContractMultiplierUnit *)new FIX::LegContractMultiplierUnit((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegContractMultiplierUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegContractMultiplierUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegContractMultiplierUnit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegContractMultiplierUnit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegContractMultiplierUnit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegContractMultiplierUnit::LegContractMultiplierUnit()\n"
    "    FIX::LegContractMultiplierUnit::LegContractMultiplierUnit(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegContractMultiplierUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegContractMultiplierUnit *arg1 = (FIX::LegContractMultiplierUnit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegContractMultiplierUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegContractMultiplierUnit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegContractMultiplierUnit" "', argument " "1"" of type '" "FIX::LegContractMultiplierUnit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegContractMultiplierUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecureData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecureData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecureData")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecureData *)new FIX::SecureData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecureData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecureData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecureData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecureData",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecureData" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecureData" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecureData *)new FIX::SecureData((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecureData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecureData(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecureData__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecureData__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecureData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecureData::SecureData()\n"
    "    FIX::SecureData::SecureData(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecureData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecureData *arg1 = (FIX::SecureData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecureData",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecureData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecureData" "', argument " "1"" of type '" "FIX::SecureData *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecureData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SenderLocationID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SenderLocationID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SenderLocationID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SenderLocationID *)new FIX::SenderLocationID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SenderLocationID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SenderLocationID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SenderLocationID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SenderLocationID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SenderLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SenderLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SenderLocationID *)new FIX::SenderLocationID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SenderLocationID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SenderLocationID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SenderLocationID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SenderLocationID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SenderLocationID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SenderLocationID::SenderLocationID()\n"
    "    FIX::SenderLocationID::SenderLocationID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SenderLocationID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SenderLocationID *arg1 = (FIX::SenderLocationID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SenderLocationID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SenderLocationID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SenderLocationID" "', argument " "1"" of type '" "FIX::SenderLocationID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SenderLocationID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FirstPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FirstPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FirstPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FirstPx *)new FIX::FirstPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FirstPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FirstPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FirstPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FirstPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FirstPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FirstPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FirstPx *)new FIX::FirstPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FirstPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FirstPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FirstPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FirstPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FirstPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FirstPx::FirstPx()\n"
    "    FIX::FirstPx::FirstPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FirstPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FirstPx *arg1 = (FIX::FirstPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FirstPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FirstPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FirstPx" "', argument " "1"" of type '" "FIX::FirstPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FirstPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedLegIssuer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedLegIssuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedLegIssuer")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedLegIssuer *)new FIX::EncodedLegIssuer();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedLegIssuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegIssuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedLegIssuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedLegIssuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedLegIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedLegIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedLegIssuer *)new FIX::EncodedLegIssuer((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedLegIssuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegIssuer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedLegIssuer__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedLegIssuer__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedLegIssuer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedLegIssuer::EncodedLegIssuer()\n"
    "    FIX::EncodedLegIssuer::EncodedLegIssuer(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedLegIssuer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedLegIssuer *arg1 = (FIX::EncodedLegIssuer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedLegIssuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedLegIssuer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedLegIssuer" "', argument " "1"" of type '" "FIX::EncodedLegIssuer *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedLegIssuer * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AssignmentMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AssignmentMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AssignmentMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AssignmentMethod *)new FIX::AssignmentMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AssignmentMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssignmentMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AssignmentMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AssignmentMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AssignmentMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AssignmentMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AssignmentMethod *)new FIX::AssignmentMethod((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AssignmentMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssignmentMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AssignmentMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AssignmentMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AssignmentMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AssignmentMethod::AssignmentMethod()\n"
    "    FIX::AssignmentMethod::AssignmentMethod(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AssignmentMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AssignmentMethod *arg1 = (FIX::AssignmentMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AssignmentMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AssignmentMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AssignmentMethod" "', argument " "1"" of type '" "FIX::AssignmentMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AssignmentMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RoutingID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RoutingID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RoutingID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RoutingID *)new FIX::RoutingID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RoutingID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoutingID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RoutingID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RoutingID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RoutingID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RoutingID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RoutingID *)new FIX::RoutingID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RoutingID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoutingID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RoutingID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RoutingID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RoutingID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RoutingID::RoutingID()\n"
    "    FIX::RoutingID::RoutingID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RoutingID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RoutingID *arg1 = (FIX::RoutingID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RoutingID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RoutingID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RoutingID" "', argument " "1"" of type '" "FIX::RoutingID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RoutingID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StrategyParameterType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrategyParameterType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StrategyParameterType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrategyParameterType *)new FIX::StrategyParameterType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrategyParameterType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrategyParameterType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrategyParameterType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrategyParameterType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrategyParameterType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrategyParameterType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrategyParameterType *)new FIX::StrategyParameterType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrategyParameterType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrategyParameterType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StrategyParameterType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrategyParameterType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StrategyParameterType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StrategyParameterType::StrategyParameterType()\n"
    "    FIX::StrategyParameterType::StrategyParameterType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StrategyParameterType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrategyParameterType *arg1 = (FIX::StrategyParameterType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrategyParameterType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StrategyParameterType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrategyParameterType" "', argument " "1"" of type '" "FIX::StrategyParameterType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StrategyParameterType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncryptMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncryptMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncryptMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncryptMethod *)new FIX::EncryptMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncryptMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncryptMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncryptMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncryptMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncryptMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncryptMethod *)new FIX::EncryptMethod((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncryptMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncryptMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncryptMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncryptMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncryptMethod::EncryptMethod()\n"
    "    FIX::EncryptMethod::EncryptMethod(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncryptMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncryptMethod *arg1 = (FIX::EncryptMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncryptMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncryptMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncryptMethod" "', argument " "1"" of type '" "FIX::EncryptMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncryptMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingStateOrProvinceOfIssue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingStateOrProvinceOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingStateOrProvinceOfIssue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingStateOrProvinceOfIssue *)new FIX::UnderlyingStateOrProvinceOfIssue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingStateOrProvinceOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStateOrProvinceOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingStateOrProvinceOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingStateOrProvinceOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingStateOrProvinceOfIssue *)new FIX::UnderlyingStateOrProvinceOfIssue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingStateOrProvinceOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStateOrProvinceOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingStateOrProvinceOfIssue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingStateOrProvinceOfIssue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingStateOrProvinceOfIssue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingStateOrProvinceOfIssue::UnderlyingStateOrProvinceOfIssue()\n"
    "    FIX::UnderlyingStateOrProvinceOfIssue::UnderlyingStateOrProvinceOfIssue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingStateOrProvinceOfIssue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingStateOrProvinceOfIssue *arg1 = (FIX::UnderlyingStateOrProvinceOfIssue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingStateOrProvinceOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingStateOrProvinceOfIssue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::UnderlyingStateOrProvinceOfIssue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingStateOrProvinceOfIssue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ApplNewSeqNum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplNewSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplNewSeqNum")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplNewSeqNum *)new FIX::ApplNewSeqNum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplNewSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplNewSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplNewSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplNewSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SEQNUM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplNewSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplNewSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplNewSeqNum *)new FIX::ApplNewSeqNum((FIX::SEQNUM const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplNewSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplNewSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplNewSeqNum__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplNewSeqNum__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplNewSeqNum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplNewSeqNum::ApplNewSeqNum()\n"
    "    FIX::ApplNewSeqNum::ApplNewSeqNum(FIX::SEQNUM const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplNewSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplNewSeqNum *arg1 = (FIX::ApplNewSeqNum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplNewSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplNewSeqNum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplNewSeqNum" "', argument " "1"" of type '" "FIX::ApplNewSeqNum *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplNewSeqNum * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeEncodedSecurityDescLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEncodedSecurityDescLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeEncodedSecurityDescLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEncodedSecurityDescLen *)new FIX::DerivativeEncodedSecurityDescLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEncodedSecurityDescLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedSecurityDescLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeEncodedSecurityDescLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeEncodedSecurityDescLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeEncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeEncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEncodedSecurityDescLen *)new FIX::DerivativeEncodedSecurityDescLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEncodedSecurityDescLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedSecurityDescLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeEncodedSecurityDescLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEncodedSecurityDescLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeEncodedSecurityDescLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeEncodedSecurityDescLen::DerivativeEncodedSecurityDescLen()\n"
    "    FIX::DerivativeEncodedSecurityDescLen::DerivativeEncodedSecurityDescLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeEncodedSecurityDescLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEncodedSecurityDescLen *arg1 = (FIX::DerivativeEncodedSecurityDescLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeEncodedSecurityDescLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeEncodedSecurityDescLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeEncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::DerivativeEncodedSecurityDescLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeEncodedSecurityDescLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradingCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradingCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradingCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradingCurrency *)new FIX::TradingCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradingCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradingCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradingCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradingCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradingCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradingCurrency *)new FIX::TradingCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradingCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradingCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradingCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradingCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradingCurrency::TradingCurrency()\n"
    "    FIX::TradingCurrency::TradingCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradingCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradingCurrency *arg1 = (FIX::TradingCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradingCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradingCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradingCurrency" "', argument " "1"" of type '" "FIX::TradingCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradingCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecondaryHighLimitPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryHighLimitPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryHighLimitPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryHighLimitPrice *)new FIX::SecondaryHighLimitPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryHighLimitPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryHighLimitPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryHighLimitPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryHighLimitPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryHighLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryHighLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryHighLimitPrice *)new FIX::SecondaryHighLimitPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryHighLimitPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryHighLimitPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryHighLimitPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryHighLimitPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryHighLimitPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryHighLimitPrice::SecondaryHighLimitPrice()\n"
    "    FIX::SecondaryHighLimitPrice::SecondaryHighLimitPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryHighLimitPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryHighLimitPrice *arg1 = (FIX::SecondaryHighLimitPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryHighLimitPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryHighLimitPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryHighLimitPrice" "', argument " "1"" of type '" "FIX::SecondaryHighLimitPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryHighLimitPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrderAvgPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderAvgPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrderAvgPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderAvgPx *)new FIX::OrderAvgPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderAvgPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderAvgPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrderAvgPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrderAvgPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrderAvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrderAvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderAvgPx *)new FIX::OrderAvgPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderAvgPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderAvgPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrderAvgPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderAvgPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrderAvgPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrderAvgPx::OrderAvgPx()\n"
    "    FIX::OrderAvgPx::OrderAvgPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrderAvgPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderAvgPx *arg1 = (FIX::OrderAvgPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrderAvgPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrderAvgPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrderAvgPx" "', argument " "1"" of type '" "FIX::OrderAvgPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrderAvgPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PosAmtType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosAmtType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PosAmtType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosAmtType *)new FIX::PosAmtType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosAmtType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosAmtType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PosAmtType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PosAmtType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PosAmtType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PosAmtType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosAmtType *)new FIX::PosAmtType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosAmtType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosAmtType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PosAmtType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosAmtType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PosAmtType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PosAmtType::PosAmtType()\n"
    "    FIX::PosAmtType::PosAmtType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PosAmtType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosAmtType *arg1 = (FIX::PosAmtType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PosAmtType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PosAmtType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PosAmtType" "', argument " "1"" of type '" "FIX::PosAmtType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PosAmtType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ResetSeqNumFlag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ResetSeqNumFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ResetSeqNumFlag")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ResetSeqNumFlag *)new FIX::ResetSeqNumFlag();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ResetSeqNumFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResetSeqNumFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ResetSeqNumFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResetSeqNumFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ResetSeqNumFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ResetSeqNumFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ResetSeqNumFlag *)new FIX::ResetSeqNumFlag((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ResetSeqNumFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResetSeqNumFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ResetSeqNumFlag__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ResetSeqNumFlag__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ResetSeqNumFlag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ResetSeqNumFlag::ResetSeqNumFlag()\n"
    "    FIX::ResetSeqNumFlag::ResetSeqNumFlag(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ResetSeqNumFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ResetSeqNumFlag *arg1 = (FIX::ResetSeqNumFlag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResetSeqNumFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ResetSeqNumFlag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResetSeqNumFlag" "', argument " "1"" of type '" "FIX::ResetSeqNumFlag *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ResetSeqNumFlag * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoHops__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoHops *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoHops")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoHops *)new FIX::NoHops();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoHops, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoHops__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoHops *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoHops",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoHops" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoHops" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoHops *)new FIX::NoHops((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoHops, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoHops(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoHops__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoHops__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoHops'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoHops::NoHops()\n"
    "    FIX::NoHops::NoHops(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoHops(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoHops *arg1 = (FIX::NoHops *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoHops",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoHops, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoHops" "', argument " "1"" of type '" "FIX::NoHops *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoHops * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CollInquiryResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollInquiryResult *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollInquiryResult")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollInquiryResult *)new FIX::CollInquiryResult();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollInquiryResult, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollInquiryResult *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollInquiryResult",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollInquiryResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollInquiryResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollInquiryResult *)new FIX::CollInquiryResult((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollInquiryResult, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryResult(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollInquiryResult__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollInquiryResult__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollInquiryResult'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollInquiryResult::CollInquiryResult()\n"
    "    FIX::CollInquiryResult::CollInquiryResult(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollInquiryResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollInquiryResult *arg1 = (FIX::CollInquiryResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollInquiryResult",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollInquiryResult, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollInquiryResult" "', argument " "1"" of type '" "FIX::CollInquiryResult *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollInquiryResult * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StartDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StartDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StartDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StartDate *)new FIX::StartDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StartDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StartDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StartDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StartDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StartDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StartDate *)new FIX::StartDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StartDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StartDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StartDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StartDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StartDate::StartDate()\n"
    "    FIX::StartDate::StartDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StartDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StartDate *arg1 = (FIX::StartDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StartDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StartDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StartDate" "', argument " "1"" of type '" "FIX::StartDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StartDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CollAsgnRespType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollAsgnRespType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollAsgnRespType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollAsgnRespType *)new FIX::CollAsgnRespType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollAsgnRespType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnRespType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollAsgnRespType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollAsgnRespType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollAsgnRespType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollAsgnRespType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollAsgnRespType *)new FIX::CollAsgnRespType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollAsgnRespType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnRespType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollAsgnRespType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollAsgnRespType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollAsgnRespType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollAsgnRespType::CollAsgnRespType()\n"
    "    FIX::CollAsgnRespType::CollAsgnRespType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollAsgnRespType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollAsgnRespType *arg1 = (FIX::CollAsgnRespType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollAsgnRespType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollAsgnRespType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollAsgnRespType" "', argument " "1"" of type '" "FIX::CollAsgnRespType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollAsgnRespType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrderBookingQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderBookingQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrderBookingQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderBookingQty *)new FIX::OrderBookingQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderBookingQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderBookingQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrderBookingQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrderBookingQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrderBookingQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrderBookingQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderBookingQty *)new FIX::OrderBookingQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderBookingQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderBookingQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrderBookingQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderBookingQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrderBookingQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrderBookingQty::OrderBookingQty()\n"
    "    FIX::OrderBookingQty::OrderBookingQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrderBookingQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderBookingQty *arg1 = (FIX::OrderBookingQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrderBookingQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrderBookingQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrderBookingQty" "', argument " "1"" of type '" "FIX::OrderBookingQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrderBookingQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoQuoteQualifiers__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoQuoteQualifiers *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoQuoteQualifiers")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoQuoteQualifiers *)new FIX::NoQuoteQualifiers();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoQuoteQualifiers, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoQuoteQualifiers__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoQuoteQualifiers *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoQuoteQualifiers",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoQuoteQualifiers" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoQuoteQualifiers" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoQuoteQualifiers *)new FIX::NoQuoteQualifiers((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoQuoteQualifiers, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoQuoteQualifiers(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoQuoteQualifiers__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoQuoteQualifiers__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoQuoteQualifiers'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoQuoteQualifiers::NoQuoteQualifiers()\n"
    "    FIX::NoQuoteQualifiers::NoQuoteQualifiers(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoQuoteQualifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoQuoteQualifiers *arg1 = (FIX::NoQuoteQualifiers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoQuoteQualifiers",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoQuoteQualifiers, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoQuoteQualifiers" "', argument " "1"" of type '" "FIX::NoQuoteQualifiers *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoQuoteQualifiers * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnsolicitedIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnsolicitedIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnsolicitedIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnsolicitedIndicator *)new FIX::UnsolicitedIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnsolicitedIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsolicitedIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnsolicitedIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnsolicitedIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnsolicitedIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnsolicitedIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnsolicitedIndicator *)new FIX::UnsolicitedIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnsolicitedIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnsolicitedIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnsolicitedIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnsolicitedIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnsolicitedIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnsolicitedIndicator::UnsolicitedIndicator()\n"
    "    FIX::UnsolicitedIndicator::UnsolicitedIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnsolicitedIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnsolicitedIndicator *arg1 = (FIX::UnsolicitedIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnsolicitedIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnsolicitedIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnsolicitedIndicator" "', argument " "1"" of type '" "FIX::UnsolicitedIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnsolicitedIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RefCstmApplVerID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefCstmApplVerID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefCstmApplVerID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefCstmApplVerID *)new FIX::RefCstmApplVerID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefCstmApplVerID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefCstmApplVerID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefCstmApplVerID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefCstmApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefCstmApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefCstmApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefCstmApplVerID *)new FIX::RefCstmApplVerID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefCstmApplVerID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefCstmApplVerID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefCstmApplVerID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefCstmApplVerID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefCstmApplVerID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefCstmApplVerID::RefCstmApplVerID()\n"
    "    FIX::RefCstmApplVerID::RefCstmApplVerID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefCstmApplVerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefCstmApplVerID *arg1 = (FIX::RefCstmApplVerID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefCstmApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefCstmApplVerID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefCstmApplVerID" "', argument " "1"" of type '" "FIX::RefCstmApplVerID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefCstmApplVerID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SideExecID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideExecID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideExecID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideExecID *)new FIX::SideExecID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideExecID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideExecID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideExecID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideExecID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideExecID *)new FIX::SideExecID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideExecID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideExecID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideExecID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideExecID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideExecID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideExecID::SideExecID()\n"
    "    FIX::SideExecID::SideExecID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideExecID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideExecID *arg1 = (FIX::SideExecID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideExecID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideExecID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideExecID" "', argument " "1"" of type '" "FIX::SideExecID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideExecID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RejectText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RejectText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RejectText")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RejectText *)new FIX::RejectText();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RejectText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RejectText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RejectText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RejectText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RejectText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RejectText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RejectText *)new FIX::RejectText((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RejectText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RejectText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RejectText__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RejectText__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RejectText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RejectText::RejectText()\n"
    "    FIX::RejectText::RejectText(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RejectText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RejectText *arg1 = (FIX::RejectText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RejectText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RejectText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RejectText" "', argument " "1"" of type '" "FIX::RejectText *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RejectText * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ExchangeSpecialInstructions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExchangeSpecialInstructions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExchangeSpecialInstructions")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExchangeSpecialInstructions *)new FIX::ExchangeSpecialInstructions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExchangeSpecialInstructions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExchangeSpecialInstructions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExchangeSpecialInstructions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExchangeSpecialInstructions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExchangeSpecialInstructions" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExchangeSpecialInstructions" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExchangeSpecialInstructions *)new FIX::ExchangeSpecialInstructions((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExchangeSpecialInstructions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExchangeSpecialInstructions(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExchangeSpecialInstructions__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExchangeSpecialInstructions__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExchangeSpecialInstructions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExchangeSpecialInstructions::ExchangeSpecialInstructions()\n"
    "    FIX::ExchangeSpecialInstructions::ExchangeSpecialInstructions(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExchangeSpecialInstructions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExchangeSpecialInstructions *arg1 = (FIX::ExchangeSpecialInstructions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExchangeSpecialInstructions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExchangeSpecialInstructions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExchangeSpecialInstructions" "', argument " "1"" of type '" "FIX::ExchangeSpecialInstructions *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExchangeSpecialInstructions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradeID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeID *)new FIX::TradeID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeID *)new FIX::TradeID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeID::TradeID()\n"
    "    FIX::TradeID::TradeID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeID *arg1 = (FIX::TradeID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeID" "', argument " "1"" of type '" "FIX::TradeID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RndPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RndPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RndPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RndPx *)new FIX::RndPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RndPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RndPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RndPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RndPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RndPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RndPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RndPx *)new FIX::RndPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RndPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RndPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RndPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RndPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RndPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RndPx::RndPx()\n"
    "    FIX::RndPx::RndPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RndPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RndPx *arg1 = (FIX::RndPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RndPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RndPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RndPx" "', argument " "1"" of type '" "FIX::RndPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RndPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_QuoteEntryRejectReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteEntryRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteEntryRejectReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteEntryRejectReason *)new FIX::QuoteEntryRejectReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteEntryRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteEntryRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteEntryRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteEntryRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteEntryRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteEntryRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteEntryRejectReason *)new FIX::QuoteEntryRejectReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteEntryRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteEntryRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteEntryRejectReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteEntryRejectReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteEntryRejectReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteEntryRejectReason::QuoteEntryRejectReason()\n"
    "    FIX::QuoteEntryRejectReason::QuoteEntryRejectReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteEntryRejectReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteEntryRejectReason *arg1 = (FIX::QuoteEntryRejectReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteEntryRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteEntryRejectReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteEntryRejectReason" "', argument " "1"" of type '" "FIX::QuoteEntryRejectReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteEntryRejectReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrderCapacity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderCapacity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrderCapacity")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderCapacity *)new FIX::OrderCapacity();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderCapacity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderCapacity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrderCapacity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrderCapacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrderCapacity" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrderCapacity" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderCapacity *)new FIX::OrderCapacity((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderCapacity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderCapacity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrderCapacity__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderCapacity__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrderCapacity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrderCapacity::OrderCapacity()\n"
    "    FIX::OrderCapacity::OrderCapacity(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrderCapacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderCapacity *arg1 = (FIX::OrderCapacity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrderCapacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrderCapacity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrderCapacity" "', argument " "1"" of type '" "FIX::OrderCapacity *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrderCapacity * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SideLastQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideLastQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideLastQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideLastQty *)new FIX::SideLastQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideLastQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideLastQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideLastQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideLastQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideLastQty" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideLastQty" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideLastQty *)new FIX::SideLastQty((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideLastQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideLastQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideLastQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideLastQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideLastQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideLastQty::SideLastQty()\n"
    "    FIX::SideLastQty::SideLastQty(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideLastQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideLastQty *arg1 = (FIX::SideLastQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideLastQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideLastQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideLastQty" "', argument " "1"" of type '" "FIX::SideLastQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideLastQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeUnitOfMeasure__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeUnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeUnitOfMeasure")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeUnitOfMeasure *)new FIX::DerivativeUnitOfMeasure();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeUnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeUnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeUnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeUnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeUnitOfMeasure *)new FIX::DerivativeUnitOfMeasure((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeUnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeUnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeUnitOfMeasure__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeUnitOfMeasure__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeUnitOfMeasure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeUnitOfMeasure::DerivativeUnitOfMeasure()\n"
    "    FIX::DerivativeUnitOfMeasure::DerivativeUnitOfMeasure(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeUnitOfMeasure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeUnitOfMeasure *arg1 = (FIX::DerivativeUnitOfMeasure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeUnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeUnitOfMeasure, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeUnitOfMeasure" "', argument " "1"" of type '" "FIX::DerivativeUnitOfMeasure *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeUnitOfMeasure * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoLegAllocs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoLegAllocs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoLegAllocs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoLegAllocs *)new FIX::NoLegAllocs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoLegAllocs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLegAllocs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoLegAllocs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoLegAllocs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoLegAllocs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoLegAllocs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoLegAllocs *)new FIX::NoLegAllocs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoLegAllocs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLegAllocs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoLegAllocs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoLegAllocs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoLegAllocs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoLegAllocs::NoLegAllocs()\n"
    "    FIX::NoLegAllocs::NoLegAllocs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoLegAllocs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoLegAllocs *arg1 = (FIX::NoLegAllocs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoLegAllocs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoLegAllocs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoLegAllocs" "', argument " "1"" of type '" "FIX::NoLegAllocs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoLegAllocs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_QuoteAckStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteAckStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteAckStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteAckStatus *)new FIX::QuoteAckStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteAckStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteAckStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteAckStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteAckStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteAckStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteAckStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteAckStatus *)new FIX::QuoteAckStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteAckStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteAckStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteAckStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteAckStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteAckStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteAckStatus::QuoteAckStatus()\n"
    "    FIX::QuoteAckStatus::QuoteAckStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteAckStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteAckStatus *arg1 = (FIX::QuoteAckStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteAckStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteAckStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteAckStatus" "', argument " "1"" of type '" "FIX::QuoteAckStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteAckStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecondaryFirmTradeID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryFirmTradeID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryFirmTradeID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryFirmTradeID *)new FIX::SecondaryFirmTradeID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryFirmTradeID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryFirmTradeID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryFirmTradeID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryFirmTradeID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryFirmTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryFirmTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryFirmTradeID *)new FIX::SecondaryFirmTradeID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryFirmTradeID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryFirmTradeID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryFirmTradeID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryFirmTradeID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryFirmTradeID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryFirmTradeID::SecondaryFirmTradeID()\n"
    "    FIX::SecondaryFirmTradeID::SecondaryFirmTradeID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryFirmTradeID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryFirmTradeID *arg1 = (FIX::SecondaryFirmTradeID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryFirmTradeID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryFirmTradeID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryFirmTradeID" "', argument " "1"" of type '" "FIX::SecondaryFirmTradeID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryFirmTradeID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UserRequestType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UserRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UserRequestType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UserRequestType *)new FIX::UserRequestType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UserRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UserRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UserRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UserRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UserRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UserRequestType *)new FIX::UserRequestType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UserRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UserRequestType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UserRequestType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UserRequestType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UserRequestType::UserRequestType()\n"
    "    FIX::UserRequestType::UserRequestType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UserRequestType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UserRequestType *arg1 = (FIX::UserRequestType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UserRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UserRequestType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UserRequestType" "', argument " "1"" of type '" "FIX::UserRequestType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UserRequestType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecondaryTrdType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryTrdType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryTrdType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryTrdType *)new FIX::SecondaryTrdType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryTrdType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTrdType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryTrdType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryTrdType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryTrdType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryTrdType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryTrdType *)new FIX::SecondaryTrdType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryTrdType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTrdType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryTrdType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryTrdType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryTrdType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryTrdType::SecondaryTrdType()\n"
    "    FIX::SecondaryTrdType::SecondaryTrdType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryTrdType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryTrdType *arg1 = (FIX::SecondaryTrdType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryTrdType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryTrdType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryTrdType" "', argument " "1"" of type '" "FIX::SecondaryTrdType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryTrdType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradeReportTransType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeReportTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeReportTransType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeReportTransType *)new FIX::TradeReportTransType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeReportTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeReportTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeReportTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeReportTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeReportTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeReportTransType *)new FIX::TradeReportTransType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeReportTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeReportTransType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeReportTransType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeReportTransType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeReportTransType::TradeReportTransType()\n"
    "    FIX::TradeReportTransType::TradeReportTransType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeReportTransType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeReportTransType *arg1 = (FIX::TradeReportTransType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeReportTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeReportTransType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeReportTransType" "', argument " "1"" of type '" "FIX::TradeReportTransType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeReportTransType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AdvSide__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AdvSide *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AdvSide")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AdvSide *)new FIX::AdvSide();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AdvSide, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvSide__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AdvSide *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AdvSide",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AdvSide" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AdvSide" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AdvSide *)new FIX::AdvSide((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AdvSide, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvSide(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AdvSide__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AdvSide__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AdvSide'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AdvSide::AdvSide()\n"
    "    FIX::AdvSide::AdvSide(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AdvSide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AdvSide *arg1 = (FIX::AdvSide *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AdvSide",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AdvSide, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AdvSide" "', argument " "1"" of type '" "FIX::AdvSide *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AdvSide * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeSecuritySubType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecuritySubType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSecuritySubType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecuritySubType *)new FIX::DerivativeSecuritySubType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecuritySubType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecuritySubType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSecuritySubType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSecuritySubType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecuritySubType *)new FIX::DerivativeSecuritySubType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecuritySubType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecuritySubType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSecuritySubType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecuritySubType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSecuritySubType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSecuritySubType::DerivativeSecuritySubType()\n"
    "    FIX::DerivativeSecuritySubType::DerivativeSecuritySubType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSecuritySubType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecuritySubType *arg1 = (FIX::DerivativeSecuritySubType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSecuritySubType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSecuritySubType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSecuritySubType" "', argument " "1"" of type '" "FIX::DerivativeSecuritySubType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSecuritySubType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TriggerTradingSessionSubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerTradingSessionSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerTradingSessionSubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerTradingSessionSubID *)new FIX::TriggerTradingSessionSubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerTradingSessionSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerTradingSessionSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerTradingSessionSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerTradingSessionSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerTradingSessionSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerTradingSessionSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerTradingSessionSubID *)new FIX::TriggerTradingSessionSubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerTradingSessionSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerTradingSessionSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerTradingSessionSubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerTradingSessionSubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerTradingSessionSubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerTradingSessionSubID::TriggerTradingSessionSubID()\n"
    "    FIX::TriggerTradingSessionSubID::TriggerTradingSessionSubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerTradingSessionSubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerTradingSessionSubID *arg1 = (FIX::TriggerTradingSessionSubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerTradingSessionSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerTradingSessionSubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerTradingSessionSubID" "', argument " "1"" of type '" "FIX::TriggerTradingSessionSubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerTradingSessionSubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradeLinkID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeLinkID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeLinkID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeLinkID *)new FIX::TradeLinkID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeLinkID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeLinkID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeLinkID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeLinkID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeLinkID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeLinkID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeLinkID *)new FIX::TradeLinkID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeLinkID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeLinkID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeLinkID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeLinkID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeLinkID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeLinkID::TradeLinkID()\n"
    "    FIX::TradeLinkID::TradeLinkID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeLinkID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeLinkID *arg1 = (FIX::TradeLinkID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeLinkID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeLinkID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeLinkID" "', argument " "1"" of type '" "FIX::TradeLinkID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeLinkID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegBenchmarkPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegBenchmarkPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegBenchmarkPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegBenchmarkPrice *)new FIX::LegBenchmarkPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegBenchmarkPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegBenchmarkPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegBenchmarkPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegBenchmarkPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegBenchmarkPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegBenchmarkPrice *)new FIX::LegBenchmarkPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegBenchmarkPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegBenchmarkPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegBenchmarkPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegBenchmarkPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegBenchmarkPrice::LegBenchmarkPrice()\n"
    "    FIX::LegBenchmarkPrice::LegBenchmarkPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegBenchmarkPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegBenchmarkPrice *arg1 = (FIX::LegBenchmarkPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegBenchmarkPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegBenchmarkPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegBenchmarkPrice" "', argument " "1"" of type '" "FIX::LegBenchmarkPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegBenchmarkPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_HopRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HopRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HopRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HopRefID *)new FIX::HopRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HopRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::HopRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HopRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SEQNUM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HopRefID" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HopRefID" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HopRefID *)new FIX::HopRefID((FIX::SEQNUM const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HopRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_HopRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HopRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HopRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::HopRefID::HopRefID()\n"
    "    FIX::HopRefID::HopRefID(FIX::SEQNUM const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HopRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HopRefID *arg1 = (FIX::HopRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HopRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__HopRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HopRefID" "', argument " "1"" of type '" "FIX::HopRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::HopRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Designation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Designation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Designation")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Designation *)new FIX::Designation();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Designation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Designation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Designation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Designation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Designation" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Designation" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Designation *)new FIX::Designation((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Designation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Designation(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Designation__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Designation__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Designation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Designation::Designation()\n"
    "    FIX::Designation::Designation(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Designation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Designation *arg1 = (FIX::Designation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Designation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Designation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Designation" "', argument " "1"" of type '" "FIX::Designation *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Designation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradeRequestID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeRequestID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeRequestID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeRequestID *)new FIX::TradeRequestID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeRequestID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeRequestID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeRequestID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeRequestID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeRequestID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeRequestID *)new FIX::TradeRequestID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeRequestID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeRequestID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeRequestID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeRequestID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeRequestID::TradeRequestID()\n"
    "    FIX::TradeRequestID::TradeRequestID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeRequestID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeRequestID *arg1 = (FIX::TradeRequestID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeRequestID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeRequestID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeRequestID" "', argument " "1"" of type '" "FIX::TradeRequestID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeRequestID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegFlowScheduleType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegFlowScheduleType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegFlowScheduleType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegFlowScheduleType *)new FIX::LegFlowScheduleType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegFlowScheduleType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegFlowScheduleType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegFlowScheduleType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegFlowScheduleType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegFlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegFlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegFlowScheduleType *)new FIX::LegFlowScheduleType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegFlowScheduleType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegFlowScheduleType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegFlowScheduleType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegFlowScheduleType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegFlowScheduleType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegFlowScheduleType::LegFlowScheduleType()\n"
    "    FIX::LegFlowScheduleType::LegFlowScheduleType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegFlowScheduleType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegFlowScheduleType *arg1 = (FIX::LegFlowScheduleType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegFlowScheduleType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegFlowScheduleType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegFlowScheduleType" "', argument " "1"" of type '" "FIX::LegFlowScheduleType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegFlowScheduleType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegPriceUnitOfMeasure__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegPriceUnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegPriceUnitOfMeasure")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegPriceUnitOfMeasure *)new FIX::LegPriceUnitOfMeasure();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegPriceUnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPriceUnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegPriceUnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegPriceUnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegPriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegPriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegPriceUnitOfMeasure *)new FIX::LegPriceUnitOfMeasure((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegPriceUnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPriceUnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegPriceUnitOfMeasure__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegPriceUnitOfMeasure__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegPriceUnitOfMeasure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegPriceUnitOfMeasure::LegPriceUnitOfMeasure()\n"
    "    FIX::LegPriceUnitOfMeasure::LegPriceUnitOfMeasure(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegPriceUnitOfMeasure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegPriceUnitOfMeasure *arg1 = (FIX::LegPriceUnitOfMeasure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegPriceUnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegPriceUnitOfMeasure, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegPriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::LegPriceUnitOfMeasure *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegPriceUnitOfMeasure * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Nested4PartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested4PartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested4PartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested4PartyIDSource *)new FIX::Nested4PartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested4PartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested4PartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested4PartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested4PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested4PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested4PartyIDSource *)new FIX::Nested4PartyIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested4PartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested4PartyIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested4PartyIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested4PartyIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested4PartyIDSource::Nested4PartyIDSource()\n"
    "    FIX::Nested4PartyIDSource::Nested4PartyIDSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested4PartyIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested4PartyIDSource *arg1 = (FIX::Nested4PartyIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested4PartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested4PartyIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested4PartyIDSource" "', argument " "1"" of type '" "FIX::Nested4PartyIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested4PartyIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CoveredOrUncovered__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CoveredOrUncovered *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CoveredOrUncovered")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CoveredOrUncovered *)new FIX::CoveredOrUncovered();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CoveredOrUncovered, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CoveredOrUncovered__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CoveredOrUncovered *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CoveredOrUncovered",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CoveredOrUncovered" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CoveredOrUncovered" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CoveredOrUncovered *)new FIX::CoveredOrUncovered((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CoveredOrUncovered, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CoveredOrUncovered(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CoveredOrUncovered__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CoveredOrUncovered__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CoveredOrUncovered'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CoveredOrUncovered::CoveredOrUncovered()\n"
    "    FIX::CoveredOrUncovered::CoveredOrUncovered(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CoveredOrUncovered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CoveredOrUncovered *arg1 = (FIX::CoveredOrUncovered *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CoveredOrUncovered",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CoveredOrUncovered, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CoveredOrUncovered" "', argument " "1"" of type '" "FIX::CoveredOrUncovered *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CoveredOrUncovered * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AcctIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AcctIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AcctIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AcctIDSource *)new FIX::AcctIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AcctIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AcctIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AcctIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AcctIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AcctIDSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AcctIDSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AcctIDSource *)new FIX::AcctIDSource((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AcctIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AcctIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AcctIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AcctIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AcctIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AcctIDSource::AcctIDSource()\n"
    "    FIX::AcctIDSource::AcctIDSource(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AcctIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AcctIDSource *arg1 = (FIX::AcctIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AcctIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AcctIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcctIDSource" "', argument " "1"" of type '" "FIX::AcctIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AcctIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MktOfferPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MktOfferPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MktOfferPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MktOfferPx *)new FIX::MktOfferPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MktOfferPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MktOfferPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MktOfferPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MktOfferPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MktOfferPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MktOfferPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MktOfferPx *)new FIX::MktOfferPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MktOfferPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MktOfferPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MktOfferPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MktOfferPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MktOfferPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MktOfferPx::MktOfferPx()\n"
    "    FIX::MktOfferPx::MktOfferPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MktOfferPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MktOfferPx *arg1 = (FIX::MktOfferPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MktOfferPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MktOfferPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MktOfferPx" "', argument " "1"" of type '" "FIX::MktOfferPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MktOfferPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoCapacities__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoCapacities *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoCapacities")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoCapacities *)new FIX::NoCapacities();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoCapacities, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoCapacities__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoCapacities *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoCapacities",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoCapacities" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoCapacities" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoCapacities *)new FIX::NoCapacities((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoCapacities, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoCapacities(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoCapacities__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoCapacities__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoCapacities'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoCapacities::NoCapacities()\n"
    "    FIX::NoCapacities::NoCapacities(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoCapacities(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoCapacities *arg1 = (FIX::NoCapacities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoCapacities",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoCapacities, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoCapacities" "', argument " "1"" of type '" "FIX::NoCapacities *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoCapacities * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradeRequestType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeRequestType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeRequestType *)new FIX::TradeRequestType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeRequestType *)new FIX::TradeRequestType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeRequestType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeRequestType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeRequestType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeRequestType::TradeRequestType()\n"
    "    FIX::TradeRequestType::TradeRequestType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeRequestType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeRequestType *arg1 = (FIX::TradeRequestType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeRequestType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeRequestType" "', argument " "1"" of type '" "FIX::TradeRequestType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeRequestType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoNestedPartyIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNestedPartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoNestedPartyIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNestedPartyIDs *)new FIX::NoNestedPartyIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNestedPartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNestedPartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoNestedPartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoNestedPartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoNestedPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoNestedPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNestedPartyIDs *)new FIX::NoNestedPartyIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNestedPartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNestedPartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoNestedPartyIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNestedPartyIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoNestedPartyIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoNestedPartyIDs::NoNestedPartyIDs()\n"
    "    FIX::NoNestedPartyIDs::NoNestedPartyIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoNestedPartyIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNestedPartyIDs *arg1 = (FIX::NoNestedPartyIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoNestedPartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoNestedPartyIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoNestedPartyIDs" "', argument " "1"" of type '" "FIX::NoNestedPartyIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoNestedPartyIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradSesStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradSesStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesStatus *)new FIX::TradSesStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesStatus *)new FIX::TradSesStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradSesStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradSesStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradSesStatus::TradSesStatus()\n"
    "    FIX::TradSesStatus::TradSesStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradSesStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesStatus *arg1 = (FIX::TradSesStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradSesStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradSesStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradSesStatus" "', argument " "1"" of type '" "FIX::TradSesStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradSesStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingNotionalPercentageOutstanding__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingNotionalPercentageOutstanding *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingNotionalPercentageOutstanding")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingNotionalPercentageOutstanding *)new FIX::UnderlyingNotionalPercentageOutstanding();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingNotionalPercentageOutstanding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingNotionalPercentageOutstanding__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingNotionalPercentageOutstanding *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingNotionalPercentageOutstanding",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingNotionalPercentageOutstanding *)new FIX::UnderlyingNotionalPercentageOutstanding((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingNotionalPercentageOutstanding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingNotionalPercentageOutstanding(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingNotionalPercentageOutstanding__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingNotionalPercentageOutstanding__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingNotionalPercentageOutstanding'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingNotionalPercentageOutstanding::UnderlyingNotionalPercentageOutstanding()\n"
    "    FIX::UnderlyingNotionalPercentageOutstanding::UnderlyingNotionalPercentageOutstanding(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingNotionalPercentageOutstanding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingNotionalPercentageOutstanding *arg1 = (FIX::UnderlyingNotionalPercentageOutstanding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingNotionalPercentageOutstanding",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingNotionalPercentageOutstanding, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::UnderlyingNotionalPercentageOutstanding *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingNotionalPercentageOutstanding * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ApplLastSeqNum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplLastSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplLastSeqNum")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplLastSeqNum *)new FIX::ApplLastSeqNum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplLastSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplLastSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplLastSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplLastSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SEQNUM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplLastSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplLastSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplLastSeqNum *)new FIX::ApplLastSeqNum((FIX::SEQNUM const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplLastSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplLastSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplLastSeqNum__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplLastSeqNum__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplLastSeqNum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplLastSeqNum::ApplLastSeqNum()\n"
    "    FIX::ApplLastSeqNum::ApplLastSeqNum(FIX::SEQNUM const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplLastSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplLastSeqNum *arg1 = (FIX::ApplLastSeqNum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplLastSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplLastSeqNum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplLastSeqNum" "', argument " "1"" of type '" "FIX::ApplLastSeqNum *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplLastSeqNum * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PegPriceType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PegPriceType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegPriceType *)new FIX::PegPriceType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PegPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PegPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PegPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PegPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegPriceType *)new FIX::PegPriceType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PegPriceType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegPriceType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PegPriceType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PegPriceType::PegPriceType()\n"
    "    FIX::PegPriceType::PegPriceType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PegPriceType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegPriceType *arg1 = (FIX::PegPriceType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PegPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PegPriceType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PegPriceType" "', argument " "1"" of type '" "FIX::PegPriceType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PegPriceType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StrategyParameterName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrategyParameterName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StrategyParameterName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrategyParameterName *)new FIX::StrategyParameterName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrategyParameterName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrategyParameterName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrategyParameterName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrategyParameterName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrategyParameterName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrategyParameterName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrategyParameterName *)new FIX::StrategyParameterName((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrategyParameterName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrategyParameterName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StrategyParameterName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrategyParameterName__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StrategyParameterName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StrategyParameterName::StrategyParameterName()\n"
    "    FIX::StrategyParameterName::StrategyParameterName(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StrategyParameterName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrategyParameterName *arg1 = (FIX::StrategyParameterName *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrategyParameterName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StrategyParameterName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrategyParameterName" "', argument " "1"" of type '" "FIX::StrategyParameterName *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StrategyParameterName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StreamAsgnRejReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StreamAsgnRejReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StreamAsgnRejReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StreamAsgnRejReason *)new FIX::StreamAsgnRejReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StreamAsgnRejReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnRejReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StreamAsgnRejReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StreamAsgnRejReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StreamAsgnRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StreamAsgnRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StreamAsgnRejReason *)new FIX::StreamAsgnRejReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StreamAsgnRejReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnRejReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StreamAsgnRejReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StreamAsgnRejReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StreamAsgnRejReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StreamAsgnRejReason::StreamAsgnRejReason()\n"
    "    FIX::StreamAsgnRejReason::StreamAsgnRejReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StreamAsgnRejReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StreamAsgnRejReason *arg1 = (FIX::StreamAsgnRejReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StreamAsgnRejReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StreamAsgnRejReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StreamAsgnRejReason" "', argument " "1"" of type '" "FIX::StreamAsgnRejReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StreamAsgnRejReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MatchIncrement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MatchIncrement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MatchIncrement")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MatchIncrement *)new FIX::MatchIncrement();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MatchIncrement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchIncrement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MatchIncrement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MatchIncrement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatchIncrement" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatchIncrement" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MatchIncrement *)new FIX::MatchIncrement((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MatchIncrement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchIncrement(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MatchIncrement__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MatchIncrement__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MatchIncrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MatchIncrement::MatchIncrement()\n"
    "    FIX::MatchIncrement::MatchIncrement(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MatchIncrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MatchIncrement *arg1 = (FIX::MatchIncrement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MatchIncrement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MatchIncrement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MatchIncrement" "', argument " "1"" of type '" "FIX::MatchIncrement *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MatchIncrement * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Nested3PartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested3PartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested3PartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested3PartyRole *)new FIX::Nested3PartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested3PartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested3PartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested3PartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested3PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested3PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested3PartyRole *)new FIX::Nested3PartyRole((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested3PartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested3PartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested3PartyRole__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested3PartyRole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested3PartyRole::Nested3PartyRole()\n"
    "    FIX::Nested3PartyRole::Nested3PartyRole(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested3PartyRole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested3PartyRole *arg1 = (FIX::Nested3PartyRole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested3PartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested3PartyRole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested3PartyRole" "', argument " "1"" of type '" "FIX::Nested3PartyRole *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested3PartyRole * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingPx *)new FIX::UnderlyingPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingPx *)new FIX::UnderlyingPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingPx::UnderlyingPx()\n"
    "    FIX::UnderlyingPx::UnderlyingPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingPx *arg1 = (FIX::UnderlyingPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingPx" "', argument " "1"" of type '" "FIX::UnderlyingPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PriceImprovement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceImprovement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PriceImprovement")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceImprovement *)new FIX::PriceImprovement();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceImprovement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceImprovement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PriceImprovement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PriceImprovement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PriceImprovement" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PriceImprovement" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceImprovement *)new FIX::PriceImprovement((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceImprovement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceImprovement(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PriceImprovement__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceImprovement__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PriceImprovement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PriceImprovement::PriceImprovement()\n"
    "    FIX::PriceImprovement::PriceImprovement(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PriceImprovement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceImprovement *arg1 = (FIX::PriceImprovement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PriceImprovement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PriceImprovement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PriceImprovement" "', argument " "1"" of type '" "FIX::PriceImprovement *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PriceImprovement * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ValuationMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ValuationMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ValuationMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ValuationMethod *)new FIX::ValuationMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ValuationMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValuationMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ValuationMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ValuationMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ValuationMethod *)new FIX::ValuationMethod((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ValuationMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValuationMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ValuationMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ValuationMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ValuationMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ValuationMethod::ValuationMethod()\n"
    "    FIX::ValuationMethod::ValuationMethod(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ValuationMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ValuationMethod *arg1 = (FIX::ValuationMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ValuationMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ValuationMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ValuationMethod" "', argument " "1"" of type '" "FIX::ValuationMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ValuationMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeSecurityID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSecurityID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityID *)new FIX::DerivativeSecurityID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityID *)new FIX::DerivativeSecurityID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSecurityID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSecurityID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSecurityID::DerivativeSecurityID()\n"
    "    FIX::DerivativeSecurityID::DerivativeSecurityID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSecurityID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityID *arg1 = (FIX::DerivativeSecurityID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSecurityID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSecurityID" "', argument " "1"" of type '" "FIX::DerivativeSecurityID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSecurityID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoExpiration__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoExpiration *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoExpiration")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoExpiration *)new FIX::NoExpiration();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoExpiration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoExpiration__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoExpiration *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoExpiration",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoExpiration" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoExpiration" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoExpiration *)new FIX::NoExpiration((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoExpiration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoExpiration(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoExpiration__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoExpiration__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoExpiration'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoExpiration::NoExpiration()\n"
    "    FIX::NoExpiration::NoExpiration(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoExpiration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoExpiration *arg1 = (FIX::NoExpiration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoExpiration",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoExpiration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoExpiration" "', argument " "1"" of type '" "FIX::NoExpiration *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoExpiration * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TargetCompID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetCompID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TargetCompID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetCompID *)new FIX::TargetCompID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetCompID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetCompID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TargetCompID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TargetCompID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TargetCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TargetCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetCompID *)new FIX::TargetCompID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetCompID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetCompID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TargetCompID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetCompID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TargetCompID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TargetCompID::TargetCompID()\n"
    "    FIX::TargetCompID::TargetCompID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TargetCompID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetCompID *arg1 = (FIX::TargetCompID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TargetCompID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TargetCompID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TargetCompID" "', argument " "1"" of type '" "FIX::TargetCompID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TargetCompID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDEntryBuyer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryBuyer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDEntryBuyer")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryBuyer *)new FIX::MDEntryBuyer();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryBuyer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryBuyer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDEntryBuyer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDEntryBuyer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDEntryBuyer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDEntryBuyer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryBuyer *)new FIX::MDEntryBuyer((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryBuyer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryBuyer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDEntryBuyer__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryBuyer__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDEntryBuyer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDEntryBuyer::MDEntryBuyer()\n"
    "    FIX::MDEntryBuyer::MDEntryBuyer(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDEntryBuyer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryBuyer *arg1 = (FIX::MDEntryBuyer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDEntryBuyer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDEntryBuyer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDEntryBuyer" "', argument " "1"" of type '" "FIX::MDEntryBuyer *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDEntryBuyer * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrumentPartySubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDerivativeInstrumentPartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoDerivativeInstrumentPartySubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDerivativeInstrumentPartySubIDs *)new FIX::NoDerivativeInstrumentPartySubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDerivativeInstrumentPartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrumentPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoDerivativeInstrumentPartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoDerivativeInstrumentPartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoDerivativeInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoDerivativeInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDerivativeInstrumentPartySubIDs *)new FIX::NoDerivativeInstrumentPartySubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDerivativeInstrumentPartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrumentPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoDerivativeInstrumentPartySubIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDerivativeInstrumentPartySubIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoDerivativeInstrumentPartySubIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoDerivativeInstrumentPartySubIDs::NoDerivativeInstrumentPartySubIDs()\n"
    "    FIX::NoDerivativeInstrumentPartySubIDs::NoDerivativeInstrumentPartySubIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoDerivativeInstrumentPartySubIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDerivativeInstrumentPartySubIDs *arg1 = (FIX::NoDerivativeInstrumentPartySubIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoDerivativeInstrumentPartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoDerivativeInstrumentPartySubIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoDerivativeInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NoDerivativeInstrumentPartySubIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoDerivativeInstrumentPartySubIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoMaturityRules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMaturityRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoMaturityRules")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMaturityRules *)new FIX::NoMaturityRules();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMaturityRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMaturityRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoMaturityRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoMaturityRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoMaturityRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoMaturityRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMaturityRules *)new FIX::NoMaturityRules((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMaturityRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMaturityRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoMaturityRules__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMaturityRules__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoMaturityRules'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoMaturityRules::NoMaturityRules()\n"
    "    FIX::NoMaturityRules::NoMaturityRules(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoMaturityRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMaturityRules *arg1 = (FIX::NoMaturityRules *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoMaturityRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoMaturityRules, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoMaturityRules" "', argument " "1"" of type '" "FIX::NoMaturityRules *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoMaturityRules * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_QuoteMsgID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteMsgID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteMsgID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteMsgID *)new FIX::QuoteMsgID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteMsgID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteMsgID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteMsgID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteMsgID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteMsgID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteMsgID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteMsgID *)new FIX::QuoteMsgID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteMsgID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteMsgID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteMsgID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteMsgID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteMsgID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteMsgID::QuoteMsgID()\n"
    "    FIX::QuoteMsgID::QuoteMsgID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteMsgID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteMsgID *arg1 = (FIX::QuoteMsgID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteMsgID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteMsgID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteMsgID" "', argument " "1"" of type '" "FIX::QuoteMsgID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteMsgID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TriggerType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerType *)new FIX::TriggerType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerType *)new FIX::TriggerType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerType::TriggerType()\n"
    "    FIX::TriggerType::TriggerType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerType *arg1 = (FIX::TriggerType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerType" "', argument " "1"" of type '" "FIX::TriggerType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PriceProtectionScope__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceProtectionScope *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PriceProtectionScope")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceProtectionScope *)new FIX::PriceProtectionScope();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceProtectionScope, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceProtectionScope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PriceProtectionScope *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PriceProtectionScope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PriceProtectionScope" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PriceProtectionScope" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceProtectionScope *)new FIX::PriceProtectionScope((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceProtectionScope, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceProtectionScope(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PriceProtectionScope__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceProtectionScope__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PriceProtectionScope'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PriceProtectionScope::PriceProtectionScope()\n"
    "    FIX::PriceProtectionScope::PriceProtectionScope(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PriceProtectionScope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceProtectionScope *arg1 = (FIX::PriceProtectionScope *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PriceProtectionScope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PriceProtectionScope, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PriceProtectionScope" "', argument " "1"" of type '" "FIX::PriceProtectionScope *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PriceProtectionScope * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TotNumAssignmentReports__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNumAssignmentReports *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotNumAssignmentReports")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNumAssignmentReports *)new FIX::TotNumAssignmentReports();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNumAssignmentReports, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNumAssignmentReports__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotNumAssignmentReports *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotNumAssignmentReports",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotNumAssignmentReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotNumAssignmentReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNumAssignmentReports *)new FIX::TotNumAssignmentReports((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNumAssignmentReports, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNumAssignmentReports(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotNumAssignmentReports__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNumAssignmentReports__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotNumAssignmentReports'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotNumAssignmentReports::TotNumAssignmentReports()\n"
    "    FIX::TotNumAssignmentReports::TotNumAssignmentReports(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotNumAssignmentReports(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNumAssignmentReports *arg1 = (FIX::TotNumAssignmentReports *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotNumAssignmentReports",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotNumAssignmentReports, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotNumAssignmentReports" "', argument " "1"" of type '" "FIX::TotNumAssignmentReports *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotNumAssignmentReports * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ContraLegRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContraLegRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ContraLegRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContraLegRefID *)new FIX::ContraLegRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContraLegRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraLegRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContraLegRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContraLegRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContraLegRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContraLegRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContraLegRefID *)new FIX::ContraLegRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContraLegRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraLegRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ContraLegRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContraLegRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContraLegRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ContraLegRefID::ContraLegRefID()\n"
    "    FIX::ContraLegRefID::ContraLegRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ContraLegRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContraLegRefID *arg1 = (FIX::ContraLegRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContraLegRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ContraLegRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContraLegRefID" "', argument " "1"" of type '" "FIX::ContraLegRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ContraLegRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradeReportRejectReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeReportRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeReportRejectReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeReportRejectReason *)new FIX::TradeReportRejectReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeReportRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeReportRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeReportRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeReportRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeReportRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeReportRejectReason *)new FIX::TradeReportRejectReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeReportRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeReportRejectReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeReportRejectReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeReportRejectReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeReportRejectReason::TradeReportRejectReason()\n"
    "    FIX::TradeReportRejectReason::TradeReportRejectReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeReportRejectReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeReportRejectReason *arg1 = (FIX::TradeReportRejectReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeReportRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeReportRejectReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeReportRejectReason" "', argument " "1"" of type '" "FIX::TradeReportRejectReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeReportRejectReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradeReportRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeReportRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeReportRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeReportRefID *)new FIX::TradeReportRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeReportRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeReportRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeReportRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeReportRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeReportRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeReportRefID *)new FIX::TradeReportRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeReportRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeReportRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeReportRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeReportRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeReportRefID::TradeReportRefID()\n"
    "    FIX::TradeReportRefID::TradeReportRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeReportRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeReportRefID *arg1 = (FIX::TradeReportRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeReportRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeReportRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeReportRefID" "', argument " "1"" of type '" "FIX::TradeReportRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeReportRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecurityListType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityListType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityListType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityListType *)new FIX::SecurityListType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityListType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityListType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityListType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityListType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityListType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityListType *)new FIX::SecurityListType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityListType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityListType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityListType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityListType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityListType::SecurityListType()\n"
    "    FIX::SecurityListType::SecurityListType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityListType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityListType *arg1 = (FIX::SecurityListType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityListType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityListType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityListType" "', argument " "1"" of type '" "FIX::SecurityListType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityListType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeSecurityIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSecurityIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityIDSource *)new FIX::DerivativeSecurityIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityIDSource *)new FIX::DerivativeSecurityIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSecurityIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSecurityIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSecurityIDSource::DerivativeSecurityIDSource()\n"
    "    FIX::DerivativeSecurityIDSource::DerivativeSecurityIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSecurityIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityIDSource *arg1 = (FIX::DerivativeSecurityIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSecurityIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSecurityIDSource" "', argument " "1"" of type '" "FIX::DerivativeSecurityIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSecurityIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AssignmentUnit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AssignmentUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AssignmentUnit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AssignmentUnit *)new FIX::AssignmentUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AssignmentUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssignmentUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AssignmentUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AssignmentUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AssignmentUnit" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AssignmentUnit" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AssignmentUnit *)new FIX::AssignmentUnit((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AssignmentUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AssignmentUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AssignmentUnit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AssignmentUnit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AssignmentUnit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AssignmentUnit::AssignmentUnit()\n"
    "    FIX::AssignmentUnit::AssignmentUnit(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AssignmentUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AssignmentUnit *arg1 = (FIX::AssignmentUnit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AssignmentUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AssignmentUnit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AssignmentUnit" "', argument " "1"" of type '" "FIX::AssignmentUnit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AssignmentUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradeReportID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeReportID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeReportID *)new FIX::TradeReportID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeReportID *)new FIX::TradeReportID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeReportID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeReportID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeReportID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeReportID::TradeReportID()\n"
    "    FIX::TradeReportID::TradeReportID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeReportID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeReportID *arg1 = (FIX::TradeReportID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeReportID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeReportID" "', argument " "1"" of type '" "FIX::TradeReportID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeReportID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoRpts__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRpts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoRpts")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRpts *)new FIX::NoRpts();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRpts, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRpts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoRpts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRpts",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoRpts" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRpts" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRpts *)new FIX::NoRpts((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRpts, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRpts(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoRpts__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoRpts__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoRpts'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoRpts::NoRpts()\n"
    "    FIX::NoRpts::NoRpts(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoRpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRpts *arg1 = (FIX::NoRpts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoRpts",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoRpts, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoRpts" "', argument " "1"" of type '" "FIX::NoRpts *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoRpts * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegBenchmarkPriceType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegBenchmarkPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegBenchmarkPriceType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegBenchmarkPriceType *)new FIX::LegBenchmarkPriceType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegBenchmarkPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegBenchmarkPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegBenchmarkPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegBenchmarkPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegBenchmarkPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegBenchmarkPriceType *)new FIX::LegBenchmarkPriceType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegBenchmarkPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegBenchmarkPriceType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegBenchmarkPriceType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegBenchmarkPriceType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegBenchmarkPriceType::LegBenchmarkPriceType()\n"
    "    FIX::LegBenchmarkPriceType::LegBenchmarkPriceType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegBenchmarkPriceType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegBenchmarkPriceType *arg1 = (FIX::LegBenchmarkPriceType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegBenchmarkPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegBenchmarkPriceType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegBenchmarkPriceType" "', argument " "1"" of type '" "FIX::LegBenchmarkPriceType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegBenchmarkPriceType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedSubjectLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedSubjectLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedSubjectLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSubjectLen *)new FIX::EncodedSubjectLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSubjectLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSubjectLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedSubjectLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedSubjectLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedSubjectLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedSubjectLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSubjectLen *)new FIX::EncodedSubjectLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSubjectLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSubjectLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedSubjectLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedSubjectLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedSubjectLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedSubjectLen::EncodedSubjectLen()\n"
    "    FIX::EncodedSubjectLen::EncodedSubjectLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedSubjectLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedSubjectLen *arg1 = (FIX::EncodedSubjectLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedSubjectLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedSubjectLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedSubjectLen" "', argument " "1"" of type '" "FIX::EncodedSubjectLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedSubjectLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecurityXML__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityXML *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityXML")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityXML *)new FIX::SecurityXML();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityXML, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityXML__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::XMLDATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityXML *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityXML",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__XMLDATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityXML" "', argument " "1"" of type '" "FIX::XMLDATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityXML" "', argument " "1"" of type '" "FIX::XMLDATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::XMLDATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityXML *)new FIX::SecurityXML((FIX::XMLDATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityXML, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityXML(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityXML__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__XMLDATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityXML__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityXML'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityXML::SecurityXML()\n"
    "    FIX::SecurityXML::SecurityXML(FIX::XMLDATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityXML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityXML *arg1 = (FIX::SecurityXML *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityXML",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityXML, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityXML" "', argument " "1"" of type '" "FIX::SecurityXML *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityXML * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegReportID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegReportID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegReportID *)new FIX::LegReportID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegReportID *)new FIX::LegReportID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegReportID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegReportID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegReportID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegReportID::LegReportID()\n"
    "    FIX::LegReportID::LegReportID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegReportID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegReportID *arg1 = (FIX::LegReportID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegReportID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegReportID" "', argument " "1"" of type '" "FIX::LegReportID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegReportID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Nested3PartySubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested3PartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested3PartySubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested3PartySubIDType *)new FIX::Nested3PartySubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested3PartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested3PartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested3PartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested3PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested3PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested3PartySubIDType *)new FIX::Nested3PartySubIDType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested3PartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested3PartySubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested3PartySubIDType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested3PartySubIDType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested3PartySubIDType::Nested3PartySubIDType()\n"
    "    FIX::Nested3PartySubIDType::Nested3PartySubIDType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested3PartySubIDType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested3PartySubIDType *arg1 = (FIX::Nested3PartySubIDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested3PartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested3PartySubIDType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested3PartySubIDType" "', argument " "1"" of type '" "FIX::Nested3PartySubIDType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested3PartySubIDType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BenchmarkSecurityIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BenchmarkSecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BenchmarkSecurityIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BenchmarkSecurityIDSource *)new FIX::BenchmarkSecurityIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BenchmarkSecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkSecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BenchmarkSecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BenchmarkSecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BenchmarkSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BenchmarkSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BenchmarkSecurityIDSource *)new FIX::BenchmarkSecurityIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BenchmarkSecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BenchmarkSecurityIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BenchmarkSecurityIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BenchmarkSecurityIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BenchmarkSecurityIDSource::BenchmarkSecurityIDSource()\n"
    "    FIX::BenchmarkSecurityIDSource::BenchmarkSecurityIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BenchmarkSecurityIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BenchmarkSecurityIDSource *arg1 = (FIX::BenchmarkSecurityIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BenchmarkSecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BenchmarkSecurityIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BenchmarkSecurityIDSource" "', argument " "1"" of type '" "FIX::BenchmarkSecurityIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BenchmarkSecurityIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_QuoteRejectReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteRejectReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteRejectReason *)new FIX::QuoteRejectReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteRejectReason *)new FIX::QuoteRejectReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteRejectReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteRejectReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteRejectReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteRejectReason::QuoteRejectReason()\n"
    "    FIX::QuoteRejectReason::QuoteRejectReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteRejectReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteRejectReason *arg1 = (FIX::QuoteRejectReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteRejectReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteRejectReason" "', argument " "1"" of type '" "FIX::QuoteRejectReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteRejectReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_HeartBtInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HeartBtInt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HeartBtInt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HeartBtInt *)new FIX::HeartBtInt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HeartBtInt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HeartBtInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::HeartBtInt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HeartBtInt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HeartBtInt" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HeartBtInt" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HeartBtInt *)new FIX::HeartBtInt((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HeartBtInt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HeartBtInt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_HeartBtInt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HeartBtInt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HeartBtInt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::HeartBtInt::HeartBtInt()\n"
    "    FIX::HeartBtInt::HeartBtInt(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HeartBtInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HeartBtInt *arg1 = (FIX::HeartBtInt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HeartBtInt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__HeartBtInt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HeartBtInt" "', argument " "1"" of type '" "FIX::HeartBtInt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::HeartBtInt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BidForwardPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidForwardPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BidForwardPoints")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidForwardPoints *)new FIX::BidForwardPoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidForwardPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidForwardPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BidForwardPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BidForwardPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BidForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BidForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidForwardPoints *)new FIX::BidForwardPoints((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidForwardPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidForwardPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BidForwardPoints__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidForwardPoints__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BidForwardPoints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BidForwardPoints::BidForwardPoints()\n"
    "    FIX::BidForwardPoints::BidForwardPoints(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BidForwardPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidForwardPoints *arg1 = (FIX::BidForwardPoints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BidForwardPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BidForwardPoints, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BidForwardPoints" "', argument " "1"" of type '" "FIX::BidForwardPoints *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BidForwardPoints * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PossResend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PossResend *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PossResend")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PossResend *)new FIX::PossResend();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PossResend, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PossResend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PossResend *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PossResend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PossResend" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PossResend" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PossResend *)new FIX::PossResend((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PossResend, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PossResend(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PossResend__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PossResend__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PossResend'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PossResend::PossResend()\n"
    "    FIX::PossResend::PossResend(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PossResend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PossResend *arg1 = (FIX::PossResend *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PossResend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PossResend, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PossResend" "', argument " "1"" of type '" "FIX::PossResend *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PossResend * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Symbol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Symbol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Symbol")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Symbol *)new FIX::Symbol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Symbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Symbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Symbol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Symbol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Symbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Symbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Symbol *)new FIX::Symbol((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Symbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Symbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Symbol__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Symbol__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Symbol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Symbol::Symbol()\n"
    "    FIX::Symbol::Symbol(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Symbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Symbol *arg1 = (FIX::Symbol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Symbol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Symbol, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Symbol" "', argument " "1"" of type '" "FIX::Symbol *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Symbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingSecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedUnderlyingSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedUnderlyingSecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedUnderlyingSecurityDesc *)new FIX::EncodedUnderlyingSecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedUnderlyingSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedUnderlyingSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedUnderlyingSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedUnderlyingSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedUnderlyingSecurityDesc *)new FIX::EncodedUnderlyingSecurityDesc((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedUnderlyingSecurityDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedUnderlyingSecurityDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedUnderlyingSecurityDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedUnderlyingSecurityDesc::EncodedUnderlyingSecurityDesc()\n"
    "    FIX::EncodedUnderlyingSecurityDesc::EncodedUnderlyingSecurityDesc(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedUnderlyingSecurityDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedUnderlyingSecurityDesc *arg1 = (FIX::EncodedUnderlyingSecurityDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedUnderlyingSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedUnderlyingSecurityDesc" "', argument " "1"" of type '" "FIX::EncodedUnderlyingSecurityDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedUnderlyingSecurityDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MarketReportID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarketReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MarketReportID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarketReportID *)new FIX::MarketReportID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarketReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MarketReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MarketReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarketReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarketReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarketReportID *)new FIX::MarketReportID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarketReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MarketReportID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarketReportID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarketReportID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MarketReportID::MarketReportID()\n"
    "    FIX::MarketReportID::MarketReportID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MarketReportID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarketReportID *arg1 = (FIX::MarketReportID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MarketReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MarketReportID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarketReportID" "', argument " "1"" of type '" "FIX::MarketReportID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MarketReportID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DiscretionPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DiscretionPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionPrice *)new FIX::DiscretionPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DiscretionPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DiscretionPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscretionPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretionPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionPrice *)new FIX::DiscretionPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DiscretionPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DiscretionPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DiscretionPrice::DiscretionPrice()\n"
    "    FIX::DiscretionPrice::DiscretionPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DiscretionPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionPrice *arg1 = (FIX::DiscretionPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DiscretionPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DiscretionPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscretionPrice" "', argument " "1"" of type '" "FIX::DiscretionPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DiscretionPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ContAmtValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContAmtValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ContAmtValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContAmtValue *)new FIX::ContAmtValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContAmtValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContAmtValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContAmtValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContAmtValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContAmtValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContAmtValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContAmtValue *)new FIX::ContAmtValue((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContAmtValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContAmtValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ContAmtValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContAmtValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContAmtValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ContAmtValue::ContAmtValue()\n"
    "    FIX::ContAmtValue::ContAmtValue(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ContAmtValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContAmtValue *arg1 = (FIX::ContAmtValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContAmtValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ContAmtValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContAmtValue" "', argument " "1"" of type '" "FIX::ContAmtValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ContAmtValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_QuantityType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuantityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuantityType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuantityType *)new FIX::QuantityType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuantityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuantityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuantityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuantityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuantityType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantityType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuantityType *)new FIX::QuantityType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuantityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuantityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuantityType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuantityType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuantityType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuantityType::QuantityType()\n"
    "    FIX::QuantityType::QuantityType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuantityType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuantityType *arg1 = (FIX::QuantityType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuantityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuantityType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuantityType" "', argument " "1"" of type '" "FIX::QuantityType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuantityType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ComplexEventPriceBoundaryMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventPriceBoundaryMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ComplexEventPriceBoundaryMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventPriceBoundaryMethod *)new FIX::ComplexEventPriceBoundaryMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventPriceBoundaryMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPriceBoundaryMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ComplexEventPriceBoundaryMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ComplexEventPriceBoundaryMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexEventPriceBoundaryMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplexEventPriceBoundaryMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventPriceBoundaryMethod *)new FIX::ComplexEventPriceBoundaryMethod((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventPriceBoundaryMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPriceBoundaryMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ComplexEventPriceBoundaryMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventPriceBoundaryMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ComplexEventPriceBoundaryMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ComplexEventPriceBoundaryMethod::ComplexEventPriceBoundaryMethod()\n"
    "    FIX::ComplexEventPriceBoundaryMethod::ComplexEventPriceBoundaryMethod(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ComplexEventPriceBoundaryMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventPriceBoundaryMethod *arg1 = (FIX::ComplexEventPriceBoundaryMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ComplexEventPriceBoundaryMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ComplexEventPriceBoundaryMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComplexEventPriceBoundaryMethod" "', argument " "1"" of type '" "FIX::ComplexEventPriceBoundaryMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ComplexEventPriceBoundaryMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ImpliedMarketIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ImpliedMarketIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ImpliedMarketIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ImpliedMarketIndicator *)new FIX::ImpliedMarketIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ImpliedMarketIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ImpliedMarketIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ImpliedMarketIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ImpliedMarketIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImpliedMarketIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImpliedMarketIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ImpliedMarketIndicator *)new FIX::ImpliedMarketIndicator((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ImpliedMarketIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ImpliedMarketIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ImpliedMarketIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ImpliedMarketIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ImpliedMarketIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ImpliedMarketIndicator::ImpliedMarketIndicator()\n"
    "    FIX::ImpliedMarketIndicator::ImpliedMarketIndicator(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ImpliedMarketIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ImpliedMarketIndicator *arg1 = (FIX::ImpliedMarketIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ImpliedMarketIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ImpliedMarketIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImpliedMarketIndicator" "', argument " "1"" of type '" "FIX::ImpliedMarketIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ImpliedMarketIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AllocClearingFeeIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocClearingFeeIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocClearingFeeIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocClearingFeeIndicator *)new FIX::AllocClearingFeeIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocClearingFeeIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocClearingFeeIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocClearingFeeIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocClearingFeeIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocClearingFeeIndicator" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocClearingFeeIndicator" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocClearingFeeIndicator *)new FIX::AllocClearingFeeIndicator((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocClearingFeeIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocClearingFeeIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocClearingFeeIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocClearingFeeIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocClearingFeeIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocClearingFeeIndicator::AllocClearingFeeIndicator()\n"
    "    FIX::AllocClearingFeeIndicator::AllocClearingFeeIndicator(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocClearingFeeIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocClearingFeeIndicator *arg1 = (FIX::AllocClearingFeeIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocClearingFeeIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocClearingFeeIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocClearingFeeIndicator" "', argument " "1"" of type '" "FIX::AllocClearingFeeIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocClearingFeeIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_QuoteRequestType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteRequestType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteRequestType *)new FIX::QuoteRequestType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteRequestType *)new FIX::QuoteRequestType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteRequestType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteRequestType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteRequestType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteRequestType::QuoteRequestType()\n"
    "    FIX::QuoteRequestType::QuoteRequestType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteRequestType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteRequestType *arg1 = (FIX::QuoteRequestType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteRequestType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteRequestType" "', argument " "1"" of type '" "FIX::QuoteRequestType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteRequestType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecurityRequestResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityRequestResult *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityRequestResult")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityRequestResult *)new FIX::SecurityRequestResult();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityRequestResult, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityRequestResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityRequestResult *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityRequestResult",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityRequestResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityRequestResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityRequestResult *)new FIX::SecurityRequestResult((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityRequestResult, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityRequestResult(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityRequestResult__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityRequestResult__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityRequestResult'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityRequestResult::SecurityRequestResult()\n"
    "    FIX::SecurityRequestResult::SecurityRequestResult(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityRequestResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityRequestResult *arg1 = (FIX::SecurityRequestResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityRequestResult",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityRequestResult, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityRequestResult" "', argument " "1"" of type '" "FIX::SecurityRequestResult *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityRequestResult * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrderRestrictions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderRestrictions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrderRestrictions")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderRestrictions *)new FIX::OrderRestrictions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderRestrictions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderRestrictions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrderRestrictions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrderRestrictions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MULTIPLECHARVALUE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrderRestrictions" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrderRestrictions" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLECHARVALUE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderRestrictions *)new FIX::OrderRestrictions((FIX::MULTIPLECHARVALUE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderRestrictions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderRestrictions(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrderRestrictions__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MULTIPLECHARVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderRestrictions__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrderRestrictions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrderRestrictions::OrderRestrictions()\n"
    "    FIX::OrderRestrictions::OrderRestrictions(FIX::MULTIPLECHARVALUE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrderRestrictions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderRestrictions *arg1 = (FIX::OrderRestrictions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrderRestrictions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrderRestrictions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrderRestrictions" "', argument " "1"" of type '" "FIX::OrderRestrictions *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrderRestrictions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoSideTrdRegTS__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSideTrdRegTS *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoSideTrdRegTS")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSideTrdRegTS *)new FIX::NoSideTrdRegTS();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSideTrdRegTS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSideTrdRegTS__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoSideTrdRegTS *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoSideTrdRegTS",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoSideTrdRegTS" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoSideTrdRegTS" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSideTrdRegTS *)new FIX::NoSideTrdRegTS((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSideTrdRegTS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSideTrdRegTS(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoSideTrdRegTS__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSideTrdRegTS__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoSideTrdRegTS'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoSideTrdRegTS::NoSideTrdRegTS()\n"
    "    FIX::NoSideTrdRegTS::NoSideTrdRegTS(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoSideTrdRegTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSideTrdRegTS *arg1 = (FIX::NoSideTrdRegTS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoSideTrdRegTS",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoSideTrdRegTS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoSideTrdRegTS" "', argument " "1"" of type '" "FIX::NoSideTrdRegTS *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoSideTrdRegTS * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Text__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Text *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Text")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Text *)new FIX::Text();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Text, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Text__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Text *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Text",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Text" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Text" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Text *)new FIX::Text((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Text, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Text(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Text__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Text__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Text'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Text::Text()\n"
    "    FIX::Text::Text(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Text *arg1 = (FIX::Text *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Text",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Text, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Text" "', argument " "1"" of type '" "FIX::Text *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Text * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedTextLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedTextLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedTextLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedTextLen *)new FIX::EncodedTextLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedTextLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedTextLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedTextLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedTextLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedTextLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedTextLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedTextLen *)new FIX::EncodedTextLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedTextLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedTextLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedTextLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedTextLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedTextLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedTextLen::EncodedTextLen()\n"
    "    FIX::EncodedTextLen::EncodedTextLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedTextLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedTextLen *arg1 = (FIX::EncodedTextLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedTextLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedTextLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedTextLen" "', argument " "1"" of type '" "FIX::EncodedTextLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedTextLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ListExecInstType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListExecInstType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ListExecInstType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListExecInstType *)new FIX::ListExecInstType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListExecInstType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListExecInstType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ListExecInstType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ListExecInstType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListExecInstType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListExecInstType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListExecInstType *)new FIX::ListExecInstType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListExecInstType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListExecInstType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ListExecInstType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListExecInstType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ListExecInstType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ListExecInstType::ListExecInstType()\n"
    "    FIX::ListExecInstType::ListExecInstType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListExecInstType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListExecInstType *arg1 = (FIX::ListExecInstType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ListExecInstType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ListExecInstType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListExecInstType" "', argument " "1"" of type '" "FIX::ListExecInstType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ListExecInstType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecondaryOrderID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryOrderID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryOrderID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryOrderID *)new FIX::SecondaryOrderID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryOrderID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryOrderID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryOrderID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryOrderID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryOrderID *)new FIX::SecondaryOrderID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryOrderID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryOrderID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryOrderID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryOrderID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryOrderID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryOrderID::SecondaryOrderID()\n"
    "    FIX::SecondaryOrderID::SecondaryOrderID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryOrderID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryOrderID *arg1 = (FIX::SecondaryOrderID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryOrderID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryOrderID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryOrderID" "', argument " "1"" of type '" "FIX::SecondaryOrderID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryOrderID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ExecBroker__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecBroker *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExecBroker")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecBroker *)new FIX::ExecBroker();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecBroker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecBroker__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExecBroker *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExecBroker",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExecBroker" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExecBroker" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecBroker *)new FIX::ExecBroker((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecBroker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecBroker(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExecBroker__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecBroker__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExecBroker'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExecBroker::ExecBroker()\n"
    "    FIX::ExecBroker::ExecBroker(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExecBroker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecBroker *arg1 = (FIX::ExecBroker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExecBroker",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExecBroker, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExecBroker" "', argument " "1"" of type '" "FIX::ExecBroker *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExecBroker * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecurityXMLLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityXMLLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityXMLLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityXMLLen *)new FIX::SecurityXMLLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityXMLLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityXMLLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityXMLLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityXMLLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityXMLLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityXMLLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityXMLLen *)new FIX::SecurityXMLLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityXMLLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityXMLLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityXMLLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityXMLLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityXMLLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityXMLLen::SecurityXMLLen()\n"
    "    FIX::SecurityXMLLen::SecurityXMLLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityXMLLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityXMLLen *arg1 = (FIX::SecurityXMLLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityXMLLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityXMLLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityXMLLen" "', argument " "1"" of type '" "FIX::SecurityXMLLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityXMLLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ApplSeqNum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplSeqNum")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplSeqNum *)new FIX::ApplSeqNum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SEQNUM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplSeqNum *)new FIX::ApplSeqNum((FIX::SEQNUM const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplSeqNum__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplSeqNum__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplSeqNum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplSeqNum::ApplSeqNum()\n"
    "    FIX::ApplSeqNum::ApplSeqNum(FIX::SEQNUM const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplSeqNum *arg1 = (FIX::ApplSeqNum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplSeqNum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplSeqNum" "', argument " "1"" of type '" "FIX::ApplSeqNum *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplSeqNum * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MaxTradeVol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaxTradeVol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaxTradeVol")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaxTradeVol *)new FIX::MaxTradeVol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaxTradeVol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxTradeVol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaxTradeVol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaxTradeVol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaxTradeVol" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaxTradeVol" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaxTradeVol *)new FIX::MaxTradeVol((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaxTradeVol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxTradeVol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaxTradeVol__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaxTradeVol__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaxTradeVol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaxTradeVol::MaxTradeVol()\n"
    "    FIX::MaxTradeVol::MaxTradeVol(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaxTradeVol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaxTradeVol *arg1 = (FIX::MaxTradeVol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaxTradeVol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaxTradeVol, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaxTradeVol" "', argument " "1"" of type '" "FIX::MaxTradeVol *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaxTradeVol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OfferSwapPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OfferSwapPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OfferSwapPoints")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OfferSwapPoints *)new FIX::OfferSwapPoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OfferSwapPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferSwapPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OfferSwapPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OfferSwapPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OfferSwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OfferSwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OfferSwapPoints *)new FIX::OfferSwapPoints((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OfferSwapPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferSwapPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OfferSwapPoints__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OfferSwapPoints__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OfferSwapPoints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OfferSwapPoints::OfferSwapPoints()\n"
    "    FIX::OfferSwapPoints::OfferSwapPoints(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OfferSwapPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OfferSwapPoints *arg1 = (FIX::OfferSwapPoints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OfferSwapPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OfferSwapPoints, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OfferSwapPoints" "', argument " "1"" of type '" "FIX::OfferSwapPoints *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OfferSwapPoints * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlPartySubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlPartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlPartySubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlPartySubIDType *)new FIX::SettlPartySubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlPartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlPartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlPartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlPartySubIDType *)new FIX::SettlPartySubIDType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlPartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlPartySubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlPartySubIDType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlPartySubIDType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlPartySubIDType::SettlPartySubIDType()\n"
    "    FIX::SettlPartySubIDType::SettlPartySubIDType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlPartySubIDType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlPartySubIDType *arg1 = (FIX::SettlPartySubIDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlPartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlPartySubIDType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlPartySubIDType" "', argument " "1"" of type '" "FIX::SettlPartySubIDType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlPartySubIDType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DistribPaymentMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DistribPaymentMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DistribPaymentMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DistribPaymentMethod *)new FIX::DistribPaymentMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DistribPaymentMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DistribPaymentMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DistribPaymentMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DistribPaymentMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DistribPaymentMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DistribPaymentMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DistribPaymentMethod *)new FIX::DistribPaymentMethod((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DistribPaymentMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DistribPaymentMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DistribPaymentMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DistribPaymentMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DistribPaymentMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DistribPaymentMethod::DistribPaymentMethod()\n"
    "    FIX::DistribPaymentMethod::DistribPaymentMethod(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DistribPaymentMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DistribPaymentMethod *arg1 = (FIX::DistribPaymentMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DistribPaymentMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DistribPaymentMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DistribPaymentMethod" "', argument " "1"" of type '" "FIX::DistribPaymentMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DistribPaymentMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TotalAffectedOrders__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalAffectedOrders *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotalAffectedOrders")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalAffectedOrders *)new FIX::TotalAffectedOrders();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalAffectedOrders, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalAffectedOrders__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotalAffectedOrders *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotalAffectedOrders",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotalAffectedOrders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotalAffectedOrders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalAffectedOrders *)new FIX::TotalAffectedOrders((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalAffectedOrders, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalAffectedOrders(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotalAffectedOrders__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalAffectedOrders__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotalAffectedOrders'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotalAffectedOrders::TotalAffectedOrders()\n"
    "    FIX::TotalAffectedOrders::TotalAffectedOrders(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotalAffectedOrders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalAffectedOrders *arg1 = (FIX::TotalAffectedOrders *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotalAffectedOrders",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotalAffectedOrders, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotalAffectedOrders" "', argument " "1"" of type '" "FIX::TotalAffectedOrders *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotalAffectedOrders * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StrikeIncrement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikeIncrement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StrikeIncrement")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeIncrement *)new FIX::StrikeIncrement();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeIncrement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeIncrement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrikeIncrement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrikeIncrement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrikeIncrement" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrikeIncrement" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeIncrement *)new FIX::StrikeIncrement((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeIncrement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeIncrement(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StrikeIncrement__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikeIncrement__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StrikeIncrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StrikeIncrement::StrikeIncrement()\n"
    "    FIX::StrikeIncrement::StrikeIncrement(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StrikeIncrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikeIncrement *arg1 = (FIX::StrikeIncrement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrikeIncrement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StrikeIncrement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrikeIncrement" "', argument " "1"" of type '" "FIX::StrikeIncrement *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StrikeIncrement * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrderHandlingInstSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderHandlingInstSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrderHandlingInstSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderHandlingInstSource *)new FIX::OrderHandlingInstSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderHandlingInstSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderHandlingInstSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrderHandlingInstSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrderHandlingInstSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrderHandlingInstSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrderHandlingInstSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderHandlingInstSource *)new FIX::OrderHandlingInstSource((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderHandlingInstSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderHandlingInstSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrderHandlingInstSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderHandlingInstSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrderHandlingInstSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrderHandlingInstSource::OrderHandlingInstSource()\n"
    "    FIX::OrderHandlingInstSource::OrderHandlingInstSource(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrderHandlingInstSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderHandlingInstSource *arg1 = (FIX::OrderHandlingInstSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrderHandlingInstSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrderHandlingInstSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrderHandlingInstSource" "', argument " "1"" of type '" "FIX::OrderHandlingInstSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrderHandlingInstSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CopyMsgIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CopyMsgIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CopyMsgIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CopyMsgIndicator *)new FIX::CopyMsgIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CopyMsgIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CopyMsgIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CopyMsgIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CopyMsgIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CopyMsgIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CopyMsgIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CopyMsgIndicator *)new FIX::CopyMsgIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CopyMsgIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CopyMsgIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CopyMsgIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CopyMsgIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CopyMsgIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CopyMsgIndicator::CopyMsgIndicator()\n"
    "    FIX::CopyMsgIndicator::CopyMsgIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CopyMsgIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CopyMsgIndicator *arg1 = (FIX::CopyMsgIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CopyMsgIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CopyMsgIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CopyMsgIndicator" "', argument " "1"" of type '" "FIX::CopyMsgIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CopyMsgIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoDlvyInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDlvyInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoDlvyInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDlvyInst *)new FIX::NoDlvyInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDlvyInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDlvyInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoDlvyInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoDlvyInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoDlvyInst" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoDlvyInst" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDlvyInst *)new FIX::NoDlvyInst((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDlvyInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDlvyInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoDlvyInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDlvyInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoDlvyInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoDlvyInst::NoDlvyInst()\n"
    "    FIX::NoDlvyInst::NoDlvyInst(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoDlvyInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDlvyInst *arg1 = (FIX::NoDlvyInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoDlvyInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoDlvyInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoDlvyInst" "', argument " "1"" of type '" "FIX::NoDlvyInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoDlvyInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_QuoteEntryID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteEntryID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteEntryID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteEntryID *)new FIX::QuoteEntryID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteEntryID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteEntryID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteEntryID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteEntryID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteEntryID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteEntryID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteEntryID *)new FIX::QuoteEntryID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteEntryID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteEntryID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteEntryID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteEntryID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteEntryID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteEntryID::QuoteEntryID()\n"
    "    FIX::QuoteEntryID::QuoteEntryID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteEntryID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteEntryID *arg1 = (FIX::QuoteEntryID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteEntryID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteEntryID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteEntryID" "', argument " "1"" of type '" "FIX::QuoteEntryID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteEntryID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AffirmStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AffirmStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AffirmStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AffirmStatus *)new FIX::AffirmStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AffirmStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AffirmStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AffirmStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AffirmStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AffirmStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AffirmStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AffirmStatus *)new FIX::AffirmStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AffirmStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AffirmStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AffirmStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AffirmStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AffirmStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AffirmStatus::AffirmStatus()\n"
    "    FIX::AffirmStatus::AffirmStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AffirmStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AffirmStatus *arg1 = (FIX::AffirmStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AffirmStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AffirmStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AffirmStatus" "', argument " "1"" of type '" "FIX::AffirmStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AffirmStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MailingInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MailingInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MailingInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MailingInst *)new FIX::MailingInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MailingInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MailingInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MailingInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MailingInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MailingInst" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MailingInst" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MailingInst *)new FIX::MailingInst((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MailingInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MailingInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MailingInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MailingInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MailingInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MailingInst::MailingInst()\n"
    "    FIX::MailingInst::MailingInst(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MailingInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MailingInst *arg1 = (FIX::MailingInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MailingInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MailingInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MailingInst" "', argument " "1"" of type '" "FIX::MailingInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MailingInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OfferSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OfferSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OfferSize")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OfferSize *)new FIX::OfferSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OfferSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OfferSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OfferSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OfferSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OfferSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OfferSize *)new FIX::OfferSize((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OfferSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OfferSize__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OfferSize__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OfferSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OfferSize::OfferSize()\n"
    "    FIX::OfferSize::OfferSize(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OfferSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OfferSize *arg1 = (FIX::OfferSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OfferSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OfferSize, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OfferSize" "', argument " "1"" of type '" "FIX::OfferSize *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OfferSize * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegSecurityType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSecurityType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecurityType *)new FIX::LegSecurityType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecurityType *)new FIX::LegSecurityType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSecurityType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecurityType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSecurityType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSecurityType::LegSecurityType()\n"
    "    FIX::LegSecurityType::LegSecurityType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSecurityType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecurityType *arg1 = (FIX::LegSecurityType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSecurityType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSecurityType" "', argument " "1"" of type '" "FIX::LegSecurityType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSecurityType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrigCustOrderCapacity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigCustOrderCapacity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrigCustOrderCapacity")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigCustOrderCapacity *)new FIX::OrigCustOrderCapacity();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigCustOrderCapacity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigCustOrderCapacity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrigCustOrderCapacity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrigCustOrderCapacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrigCustOrderCapacity" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrigCustOrderCapacity" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigCustOrderCapacity *)new FIX::OrigCustOrderCapacity((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigCustOrderCapacity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigCustOrderCapacity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrigCustOrderCapacity__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigCustOrderCapacity__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrigCustOrderCapacity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrigCustOrderCapacity::OrigCustOrderCapacity()\n"
    "    FIX::OrigCustOrderCapacity::OrigCustOrderCapacity(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrigCustOrderCapacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigCustOrderCapacity *arg1 = (FIX::OrigCustOrderCapacity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrigCustOrderCapacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrigCustOrderCapacity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrigCustOrderCapacity" "', argument " "1"" of type '" "FIX::OrigCustOrderCapacity *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrigCustOrderCapacity * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AllocMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocMethod *)new FIX::AllocMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocMethod *)new FIX::AllocMethod((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocMethod::AllocMethod()\n"
    "    FIX::AllocMethod::AllocMethod(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocMethod *arg1 = (FIX::AllocMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocMethod" "', argument " "1"" of type '" "FIX::AllocMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_QuantityDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuantityDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuantityDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuantityDate *)new FIX::QuantityDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuantityDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuantityDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuantityDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuantityDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuantityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuantityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuantityDate *)new FIX::QuantityDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuantityDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuantityDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuantityDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuantityDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuantityDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuantityDate::QuantityDate()\n"
    "    FIX::QuantityDate::QuantityDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuantityDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuantityDate *arg1 = (FIX::QuantityDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuantityDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuantityDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuantityDate" "', argument " "1"" of type '" "FIX::QuantityDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuantityDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TargetStrategyPerformance__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetStrategyPerformance *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TargetStrategyPerformance")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetStrategyPerformance *)new FIX::TargetStrategyPerformance();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetStrategyPerformance, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetStrategyPerformance__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TargetStrategyPerformance *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TargetStrategyPerformance",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TargetStrategyPerformance" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TargetStrategyPerformance" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetStrategyPerformance *)new FIX::TargetStrategyPerformance((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetStrategyPerformance, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetStrategyPerformance(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TargetStrategyPerformance__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetStrategyPerformance__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TargetStrategyPerformance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TargetStrategyPerformance::TargetStrategyPerformance()\n"
    "    FIX::TargetStrategyPerformance::TargetStrategyPerformance(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TargetStrategyPerformance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetStrategyPerformance *arg1 = (FIX::TargetStrategyPerformance *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TargetStrategyPerformance",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TargetStrategyPerformance, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TargetStrategyPerformance" "', argument " "1"" of type '" "FIX::TargetStrategyPerformance *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TargetStrategyPerformance * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CardExpDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CardExpDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CardExpDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CardExpDate *)new FIX::CardExpDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CardExpDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardExpDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CardExpDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CardExpDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CardExpDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CardExpDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CardExpDate *)new FIX::CardExpDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CardExpDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardExpDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CardExpDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CardExpDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CardExpDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CardExpDate::CardExpDate()\n"
    "    FIX::CardExpDate::CardExpDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CardExpDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CardExpDate *arg1 = (FIX::CardExpDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CardExpDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CardExpDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CardExpDate" "', argument " "1"" of type '" "FIX::CardExpDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CardExpDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ConfirmID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfirmID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ConfirmID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfirmID *)new FIX::ConfirmID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfirmID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ConfirmID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ConfirmID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfirmID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConfirmID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfirmID *)new FIX::ConfirmID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfirmID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ConfirmID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfirmID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ConfirmID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ConfirmID::ConfirmID()\n"
    "    FIX::ConfirmID::ConfirmID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConfirmID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfirmID *arg1 = (FIX::ConfirmID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ConfirmID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ConfirmID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfirmID" "', argument " "1"" of type '" "FIX::ConfirmID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ConfirmID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StandInstDbName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StandInstDbName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StandInstDbName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StandInstDbName *)new FIX::StandInstDbName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StandInstDbName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StandInstDbName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StandInstDbName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StandInstDbName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StandInstDbName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StandInstDbName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StandInstDbName *)new FIX::StandInstDbName((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StandInstDbName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StandInstDbName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StandInstDbName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StandInstDbName__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StandInstDbName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StandInstDbName::StandInstDbName()\n"
    "    FIX::StandInstDbName::StandInstDbName(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StandInstDbName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StandInstDbName *arg1 = (FIX::StandInstDbName *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StandInstDbName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StandInstDbName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StandInstDbName" "', argument " "1"" of type '" "FIX::StandInstDbName *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StandInstDbName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DayOrderQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DayOrderQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DayOrderQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DayOrderQty *)new FIX::DayOrderQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DayOrderQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayOrderQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DayOrderQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DayOrderQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DayOrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DayOrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DayOrderQty *)new FIX::DayOrderQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DayOrderQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayOrderQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DayOrderQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DayOrderQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DayOrderQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DayOrderQty::DayOrderQty()\n"
    "    FIX::DayOrderQty::DayOrderQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DayOrderQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DayOrderQty *arg1 = (FIX::DayOrderQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DayOrderQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DayOrderQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DayOrderQty" "', argument " "1"" of type '" "FIX::DayOrderQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DayOrderQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_HighLimitPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HighLimitPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HighLimitPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HighLimitPrice *)new FIX::HighLimitPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HighLimitPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HighLimitPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::HighLimitPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HighLimitPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HighLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HighLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HighLimitPrice *)new FIX::HighLimitPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HighLimitPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HighLimitPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_HighLimitPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HighLimitPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HighLimitPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::HighLimitPrice::HighLimitPrice()\n"
    "    FIX::HighLimitPrice::HighLimitPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HighLimitPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HighLimitPrice *arg1 = (FIX::HighLimitPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HighLimitPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__HighLimitPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HighLimitPrice" "', argument " "1"" of type '" "FIX::HighLimitPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::HighLimitPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FirmTradeID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FirmTradeID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FirmTradeID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FirmTradeID *)new FIX::FirmTradeID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FirmTradeID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FirmTradeID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FirmTradeID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FirmTradeID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FirmTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FirmTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FirmTradeID *)new FIX::FirmTradeID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FirmTradeID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FirmTradeID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FirmTradeID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FirmTradeID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FirmTradeID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FirmTradeID::FirmTradeID()\n"
    "    FIX::FirmTradeID::FirmTradeID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FirmTradeID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FirmTradeID *arg1 = (FIX::FirmTradeID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FirmTradeID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FirmTradeID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FirmTradeID" "', argument " "1"" of type '" "FIX::FirmTradeID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FirmTradeID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecondaryIndividualAllocID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryIndividualAllocID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryIndividualAllocID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryIndividualAllocID *)new FIX::SecondaryIndividualAllocID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryIndividualAllocID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryIndividualAllocID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryIndividualAllocID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryIndividualAllocID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryIndividualAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryIndividualAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryIndividualAllocID *)new FIX::SecondaryIndividualAllocID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryIndividualAllocID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryIndividualAllocID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryIndividualAllocID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryIndividualAllocID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryIndividualAllocID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryIndividualAllocID::SecondaryIndividualAllocID()\n"
    "    FIX::SecondaryIndividualAllocID::SecondaryIndividualAllocID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryIndividualAllocID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryIndividualAllocID *arg1 = (FIX::SecondaryIndividualAllocID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryIndividualAllocID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryIndividualAllocID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryIndividualAllocID" "', argument " "1"" of type '" "FIX::SecondaryIndividualAllocID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryIndividualAllocID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AgreementDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AgreementDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AgreementDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AgreementDesc *)new FIX::AgreementDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AgreementDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AgreementDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AgreementDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AgreementDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AgreementDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AgreementDesc *)new FIX::AgreementDesc((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AgreementDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AgreementDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AgreementDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AgreementDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AgreementDesc::AgreementDesc()\n"
    "    FIX::AgreementDesc::AgreementDesc(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AgreementDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AgreementDesc *arg1 = (FIX::AgreementDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AgreementDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AgreementDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AgreementDesc" "', argument " "1"" of type '" "FIX::AgreementDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AgreementDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MassCancelResponse__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassCancelResponse *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MassCancelResponse")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassCancelResponse *)new FIX::MassCancelResponse();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassCancelResponse, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassCancelResponse__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MassCancelResponse *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MassCancelResponse",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassCancelResponse" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassCancelResponse" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassCancelResponse *)new FIX::MassCancelResponse((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassCancelResponse, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassCancelResponse(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MassCancelResponse__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassCancelResponse__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MassCancelResponse'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MassCancelResponse::MassCancelResponse()\n"
    "    FIX::MassCancelResponse::MassCancelResponse(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MassCancelResponse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassCancelResponse *arg1 = (FIX::MassCancelResponse *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MassCancelResponse",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MassCancelResponse, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MassCancelResponse" "', argument " "1"" of type '" "FIX::MassCancelResponse *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MassCancelResponse * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegSettlCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSettlCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSettlCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSettlCurrency *)new FIX::LegSettlCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSettlCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSettlCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSettlCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSettlCurrency *)new FIX::LegSettlCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSettlCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSettlCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSettlCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSettlCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSettlCurrency::LegSettlCurrency()\n"
    "    FIX::LegSettlCurrency::LegSettlCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSettlCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSettlCurrency *arg1 = (FIX::LegSettlCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSettlCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSettlCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSettlCurrency" "', argument " "1"" of type '" "FIX::LegSettlCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSettlCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Commission__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Commission *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Commission")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Commission *)new FIX::Commission();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Commission, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Commission__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Commission *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Commission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Commission" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Commission" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Commission *)new FIX::Commission((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Commission, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Commission(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Commission__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Commission__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Commission'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Commission::Commission()\n"
    "    FIX::Commission::Commission(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Commission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Commission *arg1 = (FIX::Commission *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Commission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Commission, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Commission" "', argument " "1"" of type '" "FIX::Commission *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Commission * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StreamAsgnReqType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StreamAsgnReqType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StreamAsgnReqType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StreamAsgnReqType *)new FIX::StreamAsgnReqType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StreamAsgnReqType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnReqType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StreamAsgnReqType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StreamAsgnReqType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StreamAsgnReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StreamAsgnReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StreamAsgnReqType *)new FIX::StreamAsgnReqType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StreamAsgnReqType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnReqType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StreamAsgnReqType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StreamAsgnReqType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StreamAsgnReqType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StreamAsgnReqType::StreamAsgnReqType()\n"
    "    FIX::StreamAsgnReqType::StreamAsgnReqType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StreamAsgnReqType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StreamAsgnReqType *arg1 = (FIX::StreamAsgnReqType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StreamAsgnReqType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StreamAsgnReqType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StreamAsgnReqType" "', argument " "1"" of type '" "FIX::StreamAsgnReqType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StreamAsgnReqType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BidSwapPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidSwapPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BidSwapPoints")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidSwapPoints *)new FIX::BidSwapPoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidSwapPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidSwapPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BidSwapPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BidSwapPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BidSwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BidSwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidSwapPoints *)new FIX::BidSwapPoints((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidSwapPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidSwapPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BidSwapPoints__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidSwapPoints__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BidSwapPoints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BidSwapPoints::BidSwapPoints()\n"
    "    FIX::BidSwapPoints::BidSwapPoints(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BidSwapPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidSwapPoints *arg1 = (FIX::BidSwapPoints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BidSwapPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BidSwapPoints, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BidSwapPoints" "', argument " "1"" of type '" "FIX::BidSwapPoints *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BidSwapPoints * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoSettlPartyIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSettlPartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoSettlPartyIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSettlPartyIDs *)new FIX::NoSettlPartyIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSettlPartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlPartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoSettlPartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoSettlPartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoSettlPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoSettlPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSettlPartyIDs *)new FIX::NoSettlPartyIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSettlPartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlPartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoSettlPartyIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSettlPartyIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoSettlPartyIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoSettlPartyIDs::NoSettlPartyIDs()\n"
    "    FIX::NoSettlPartyIDs::NoSettlPartyIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoSettlPartyIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSettlPartyIDs *arg1 = (FIX::NoSettlPartyIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoSettlPartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoSettlPartyIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoSettlPartyIDs" "', argument " "1"" of type '" "FIX::NoSettlPartyIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoSettlPartyIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SymbolSfx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SymbolSfx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SymbolSfx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SymbolSfx *)new FIX::SymbolSfx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SymbolSfx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SymbolSfx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SymbolSfx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SymbolSfx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SymbolSfx *)new FIX::SymbolSfx((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SymbolSfx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SymbolSfx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SymbolSfx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SymbolSfx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SymbolSfx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SymbolSfx::SymbolSfx()\n"
    "    FIX::SymbolSfx::SymbolSfx(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SymbolSfx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SymbolSfx *arg1 = (FIX::SymbolSfx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SymbolSfx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SymbolSfx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SymbolSfx" "', argument " "1"" of type '" "FIX::SymbolSfx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SymbolSfx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BusinessRejectRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BusinessRejectRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BusinessRejectRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BusinessRejectRefID *)new FIX::BusinessRejectRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BusinessRejectRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BusinessRejectRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BusinessRejectRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BusinessRejectRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusinessRejectRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BusinessRejectRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BusinessRejectRefID *)new FIX::BusinessRejectRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BusinessRejectRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BusinessRejectRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BusinessRejectRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BusinessRejectRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BusinessRejectRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BusinessRejectRefID::BusinessRejectRefID()\n"
    "    FIX::BusinessRejectRefID::BusinessRejectRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BusinessRejectRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BusinessRejectRefID *arg1 = (FIX::BusinessRejectRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BusinessRejectRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BusinessRejectRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusinessRejectRefID" "', argument " "1"" of type '" "FIX::BusinessRejectRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BusinessRejectRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Price2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Price2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Price2")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Price2 *)new FIX::Price2();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Price2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Price2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Price2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Price2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Price2" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Price2" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Price2 *)new FIX::Price2((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Price2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Price2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Price2__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Price2__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Price2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Price2::Price2()\n"
    "    FIX::Price2::Price2(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Price2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Price2 *arg1 = (FIX::Price2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Price2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Price2, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Price2" "', argument " "1"" of type '" "FIX::Price2 *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Price2 * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FillLiquidityInd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FillLiquidityInd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FillLiquidityInd")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FillLiquidityInd *)new FIX::FillLiquidityInd();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FillLiquidityInd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillLiquidityInd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FillLiquidityInd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FillLiquidityInd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FillLiquidityInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FillLiquidityInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FillLiquidityInd *)new FIX::FillLiquidityInd((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FillLiquidityInd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillLiquidityInd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FillLiquidityInd__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FillLiquidityInd__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FillLiquidityInd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FillLiquidityInd::FillLiquidityInd()\n"
    "    FIX::FillLiquidityInd::FillLiquidityInd(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FillLiquidityInd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FillLiquidityInd *arg1 = (FIX::FillLiquidityInd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FillLiquidityInd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FillLiquidityInd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FillLiquidityInd" "', argument " "1"" of type '" "FIX::FillLiquidityInd *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FillLiquidityInd * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MassActionReportID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassActionReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MassActionReportID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassActionReportID *)new FIX::MassActionReportID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassActionReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MassActionReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MassActionReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassActionReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassActionReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassActionReportID *)new FIX::MassActionReportID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassActionReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MassActionReportID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassActionReportID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MassActionReportID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MassActionReportID::MassActionReportID()\n"
    "    FIX::MassActionReportID::MassActionReportID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MassActionReportID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassActionReportID *arg1 = (FIX::MassActionReportID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MassActionReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MassActionReportID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MassActionReportID" "', argument " "1"" of type '" "FIX::MassActionReportID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MassActionReportID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeIssuer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeIssuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeIssuer")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeIssuer *)new FIX::DerivativeIssuer();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeIssuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeIssuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeIssuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeIssuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeIssuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeIssuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeIssuer *)new FIX::DerivativeIssuer((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeIssuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeIssuer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeIssuer__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeIssuer__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeIssuer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeIssuer::DerivativeIssuer()\n"
    "    FIX::DerivativeIssuer::DerivativeIssuer(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeIssuer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeIssuer *arg1 = (FIX::DerivativeIssuer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeIssuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeIssuer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeIssuer" "', argument " "1"" of type '" "FIX::DerivativeIssuer *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeIssuer * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ExDestinationIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExDestinationIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExDestinationIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExDestinationIDSource *)new FIX::ExDestinationIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExDestinationIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExDestinationIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExDestinationIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExDestinationIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExDestinationIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExDestinationIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExDestinationIDSource *)new FIX::ExDestinationIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExDestinationIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExDestinationIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExDestinationIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExDestinationIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExDestinationIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExDestinationIDSource::ExDestinationIDSource()\n"
    "    FIX::ExDestinationIDSource::ExDestinationIDSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExDestinationIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExDestinationIDSource *arg1 = (FIX::ExDestinationIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExDestinationIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExDestinationIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExDestinationIDSource" "', argument " "1"" of type '" "FIX::ExDestinationIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExDestinationIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CollRespID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollRespID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollRespID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollRespID *)new FIX::CollRespID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollRespID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollRespID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollRespID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollRespID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollRespID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollRespID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollRespID *)new FIX::CollRespID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollRespID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollRespID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollRespID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollRespID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollRespID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollRespID::CollRespID()\n"
    "    FIX::CollRespID::CollRespID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollRespID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollRespID *arg1 = (FIX::CollRespID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollRespID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollRespID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollRespID" "', argument " "1"" of type '" "FIX::CollRespID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollRespID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecurityListRequestType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityListRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityListRequestType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityListRequestType *)new FIX::SecurityListRequestType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityListRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityListRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityListRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityListRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityListRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityListRequestType *)new FIX::SecurityListRequestType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityListRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityListRequestType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityListRequestType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityListRequestType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityListRequestType::SecurityListRequestType()\n"
    "    FIX::SecurityListRequestType::SecurityListRequestType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityListRequestType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityListRequestType *arg1 = (FIX::SecurityListRequestType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityListRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityListRequestType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityListRequestType" "', argument " "1"" of type '" "FIX::SecurityListRequestType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityListRequestType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedLegSecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedLegSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedLegSecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedLegSecurityDesc *)new FIX::EncodedLegSecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedLegSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedLegSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedLegSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedLegSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedLegSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedLegSecurityDesc *)new FIX::EncodedLegSecurityDesc((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedLegSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedLegSecurityDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedLegSecurityDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedLegSecurityDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedLegSecurityDesc::EncodedLegSecurityDesc()\n"
    "    FIX::EncodedLegSecurityDesc::EncodedLegSecurityDesc(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedLegSecurityDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedLegSecurityDesc *arg1 = (FIX::EncodedLegSecurityDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedLegSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedLegSecurityDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedLegSecurityDesc" "', argument " "1"" of type '" "FIX::EncodedLegSecurityDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedLegSecurityDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSettlementStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSettlementStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSettlementStatus *)new FIX::UnderlyingSettlementStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSettlementStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSettlementStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSettlementStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSettlementStatus" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSettlementStatus" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSettlementStatus *)new FIX::UnderlyingSettlementStatus((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSettlementStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSettlementStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSettlementStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSettlementStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSettlementStatus::UnderlyingSettlementStatus()\n"
    "    FIX::UnderlyingSettlementStatus::UnderlyingSettlementStatus(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSettlementStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSettlementStatus *arg1 = (FIX::UnderlyingSettlementStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSettlementStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSettlementStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSettlementStatus" "', argument " "1"" of type '" "FIX::UnderlyingSettlementStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSettlementStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecurityAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityAltID *)new FIX::SecurityAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityAltID *)new FIX::SecurityAltID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityAltID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityAltID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityAltID::SecurityAltID()\n"
    "    FIX::SecurityAltID::SecurityAltID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityAltID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityAltID *arg1 = (FIX::SecurityAltID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityAltID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityAltID" "', argument " "1"" of type '" "FIX::SecurityAltID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityAltID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RegistRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RegistRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistRefID *)new FIX::RegistRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RegistRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RegistRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegistRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegistRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistRefID *)new FIX::RegistRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RegistRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RegistRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RegistRefID::RegistRefID()\n"
    "    FIX::RegistRefID::RegistRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RegistRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistRefID *arg1 = (FIX::RegistRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RegistRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RegistRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegistRefID" "', argument " "1"" of type '" "FIX::RegistRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RegistRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativePriceQuoteMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativePriceQuoteMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativePriceQuoteMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativePriceQuoteMethod *)new FIX::DerivativePriceQuoteMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativePriceQuoteMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePriceQuoteMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativePriceQuoteMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativePriceQuoteMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativePriceQuoteMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativePriceQuoteMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativePriceQuoteMethod *)new FIX::DerivativePriceQuoteMethod((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativePriceQuoteMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePriceQuoteMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativePriceQuoteMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativePriceQuoteMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativePriceQuoteMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativePriceQuoteMethod::DerivativePriceQuoteMethod()\n"
    "    FIX::DerivativePriceQuoteMethod::DerivativePriceQuoteMethod(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativePriceQuoteMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativePriceQuoteMethod *arg1 = (FIX::DerivativePriceQuoteMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativePriceQuoteMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativePriceQuoteMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativePriceQuoteMethod" "', argument " "1"" of type '" "FIX::DerivativePriceQuoteMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativePriceQuoteMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrderDelay__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderDelay *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrderDelay")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderDelay *)new FIX::OrderDelay();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderDelay, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderDelay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrderDelay *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrderDelay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrderDelay" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrderDelay" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderDelay *)new FIX::OrderDelay((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderDelay, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderDelay(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrderDelay__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderDelay__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrderDelay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrderDelay::OrderDelay()\n"
    "    FIX::OrderDelay::OrderDelay(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrderDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderDelay *arg1 = (FIX::OrderDelay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrderDelay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrderDelay, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrderDelay" "', argument " "1"" of type '" "FIX::OrderDelay *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrderDelay * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoNotAffectedOrders__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNotAffectedOrders *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoNotAffectedOrders")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNotAffectedOrders *)new FIX::NoNotAffectedOrders();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNotAffectedOrders, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNotAffectedOrders__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoNotAffectedOrders *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoNotAffectedOrders",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoNotAffectedOrders" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoNotAffectedOrders" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNotAffectedOrders *)new FIX::NoNotAffectedOrders((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNotAffectedOrders, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNotAffectedOrders(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoNotAffectedOrders__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNotAffectedOrders__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoNotAffectedOrders'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoNotAffectedOrders::NoNotAffectedOrders()\n"
    "    FIX::NoNotAffectedOrders::NoNotAffectedOrders(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoNotAffectedOrders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNotAffectedOrders *arg1 = (FIX::NoNotAffectedOrders *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoNotAffectedOrders",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoNotAffectedOrders, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoNotAffectedOrders" "', argument " "1"" of type '" "FIX::NoNotAffectedOrders *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoNotAffectedOrders * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Nested3PartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested3PartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested3PartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested3PartyID *)new FIX::Nested3PartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested3PartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested3PartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested3PartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested3PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested3PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested3PartyID *)new FIX::Nested3PartyID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested3PartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested3PartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested3PartyID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested3PartyID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested3PartyID::Nested3PartyID()\n"
    "    FIX::Nested3PartyID::Nested3PartyID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested3PartyID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested3PartyID *arg1 = (FIX::Nested3PartyID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested3PartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested3PartyID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested3PartyID" "', argument " "1"" of type '" "FIX::Nested3PartyID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested3PartyID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CollAsgnReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollAsgnReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollAsgnReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollAsgnReason *)new FIX::CollAsgnReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollAsgnReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollAsgnReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollAsgnReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollAsgnReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollAsgnReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollAsgnReason *)new FIX::CollAsgnReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollAsgnReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollAsgnReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollAsgnReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollAsgnReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollAsgnReason::CollAsgnReason()\n"
    "    FIX::CollAsgnReason::CollAsgnReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollAsgnReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollAsgnReason *arg1 = (FIX::CollAsgnReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollAsgnReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollAsgnReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollAsgnReason" "', argument " "1"" of type '" "FIX::CollAsgnReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollAsgnReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TotalVolumeTradedTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalVolumeTradedTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotalVolumeTradedTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalVolumeTradedTime *)new FIX::TotalVolumeTradedTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalVolumeTradedTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalVolumeTradedTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMEONLY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotalVolumeTradedTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotalVolumeTradedTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMEONLY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotalVolumeTradedTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotalVolumeTradedTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMEONLY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalVolumeTradedTime *)new FIX::TotalVolumeTradedTime((FIX::UTCTIMEONLY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalVolumeTradedTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalVolumeTradedTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotalVolumeTradedTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalVolumeTradedTime__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotalVolumeTradedTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotalVolumeTradedTime::TotalVolumeTradedTime()\n"
    "    FIX::TotalVolumeTradedTime::TotalVolumeTradedTime(FIX::UTCTIMEONLY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotalVolumeTradedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalVolumeTradedTime *arg1 = (FIX::TotalVolumeTradedTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotalVolumeTradedTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotalVolumeTradedTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotalVolumeTradedTime" "', argument " "1"" of type '" "FIX::TotalVolumeTradedTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotalVolumeTradedTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecurityExchange__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityExchange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityExchange")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityExchange *)new FIX::SecurityExchange();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityExchange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityExchange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityExchange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityExchange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityExchange *)new FIX::SecurityExchange((FIX::EXCHANGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityExchange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityExchange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityExchange__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityExchange__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityExchange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityExchange::SecurityExchange()\n"
    "    FIX::SecurityExchange::SecurityExchange(FIX::EXCHANGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityExchange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityExchange *arg1 = (FIX::SecurityExchange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityExchange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityExchange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityExchange" "', argument " "1"" of type '" "FIX::SecurityExchange *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityExchange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlPriceType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlPriceType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlPriceType *)new FIX::SettlPriceType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlPriceType *)new FIX::SettlPriceType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlPriceType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlPriceType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlPriceType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlPriceType::SettlPriceType()\n"
    "    FIX::SettlPriceType::SettlPriceType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlPriceType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlPriceType *arg1 = (FIX::SettlPriceType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlPriceType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlPriceType" "', argument " "1"" of type '" "FIX::SettlPriceType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlPriceType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnitOfMeasureQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnitOfMeasureQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnitOfMeasureQty *)new FIX::UnitOfMeasureQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnitOfMeasureQty *)new FIX::UnitOfMeasureQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnitOfMeasureQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnitOfMeasureQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnitOfMeasureQty::UnitOfMeasureQty()\n"
    "    FIX::UnitOfMeasureQty::UnitOfMeasureQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnitOfMeasureQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnitOfMeasureQty *arg1 = (FIX::UnitOfMeasureQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnitOfMeasureQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnitOfMeasureQty" "', argument " "1"" of type '" "FIX::UnitOfMeasureQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnitOfMeasureQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UserRequestID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UserRequestID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UserRequestID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UserRequestID *)new FIX::UserRequestID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UserRequestID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserRequestID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UserRequestID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UserRequestID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UserRequestID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UserRequestID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UserRequestID *)new FIX::UserRequestID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UserRequestID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserRequestID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UserRequestID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UserRequestID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UserRequestID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UserRequestID::UserRequestID()\n"
    "    FIX::UserRequestID::UserRequestID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UserRequestID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UserRequestID *arg1 = (FIX::UserRequestID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UserRequestID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UserRequestID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UserRequestID" "', argument " "1"" of type '" "FIX::UserRequestID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UserRequestID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LastParPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastParPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastParPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastParPx *)new FIX::LastParPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastParPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastParPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastParPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastParPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastParPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastParPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastParPx *)new FIX::LastParPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastParPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastParPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastParPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastParPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastParPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastParPx::LastParPx()\n"
    "    FIX::LastParPx::LastParPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastParPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastParPx *arg1 = (FIX::LastParPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastParPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastParPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastParPx" "', argument " "1"" of type '" "FIX::LastParPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastParPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EndMaturityMonthYear__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EndMaturityMonthYear *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EndMaturityMonthYear")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EndMaturityMonthYear *)new FIX::EndMaturityMonthYear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EndMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndMaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EndMaturityMonthYear *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EndMaturityMonthYear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EndMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EndMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EndMaturityMonthYear *)new FIX::EndMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EndMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndMaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EndMaturityMonthYear__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EndMaturityMonthYear__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EndMaturityMonthYear'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EndMaturityMonthYear::EndMaturityMonthYear()\n"
    "    FIX::EndMaturityMonthYear::EndMaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EndMaturityMonthYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EndMaturityMonthYear *arg1 = (FIX::EndMaturityMonthYear *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EndMaturityMonthYear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EndMaturityMonthYear, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EndMaturityMonthYear" "', argument " "1"" of type '" "FIX::EndMaturityMonthYear *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EndMaturityMonthYear * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DealingCapacity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DealingCapacity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DealingCapacity")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DealingCapacity *)new FIX::DealingCapacity();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DealingCapacity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DealingCapacity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DealingCapacity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DealingCapacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DealingCapacity" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DealingCapacity" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DealingCapacity *)new FIX::DealingCapacity((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DealingCapacity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DealingCapacity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DealingCapacity__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DealingCapacity__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DealingCapacity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DealingCapacity::DealingCapacity()\n"
    "    FIX::DealingCapacity::DealingCapacity(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DealingCapacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DealingCapacity *arg1 = (FIX::DealingCapacity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DealingCapacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DealingCapacity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DealingCapacity" "', argument " "1"" of type '" "FIX::DealingCapacity *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DealingCapacity * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PrevClosePx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PrevClosePx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PrevClosePx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PrevClosePx *)new FIX::PrevClosePx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PrevClosePx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PrevClosePx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PrevClosePx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PrevClosePx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PrevClosePx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PrevClosePx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PrevClosePx *)new FIX::PrevClosePx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PrevClosePx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PrevClosePx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PrevClosePx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PrevClosePx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PrevClosePx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PrevClosePx::PrevClosePx()\n"
    "    FIX::PrevClosePx::PrevClosePx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PrevClosePx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PrevClosePx *arg1 = (FIX::PrevClosePx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PrevClosePx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PrevClosePx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PrevClosePx" "', argument " "1"" of type '" "FIX::PrevClosePx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PrevClosePx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradeInputDevice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeInputDevice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeInputDevice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeInputDevice *)new FIX::TradeInputDevice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeInputDevice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeInputDevice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeInputDevice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeInputDevice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeInputDevice" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeInputDevice" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeInputDevice *)new FIX::TradeInputDevice((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeInputDevice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeInputDevice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeInputDevice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeInputDevice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeInputDevice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeInputDevice::TradeInputDevice()\n"
    "    FIX::TradeInputDevice::TradeInputDevice(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeInputDevice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeInputDevice *arg1 = (FIX::TradeInputDevice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeInputDevice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeInputDevice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeInputDevice" "', argument " "1"" of type '" "FIX::TradeInputDevice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeInputDevice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DayCumQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DayCumQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DayCumQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DayCumQty *)new FIX::DayCumQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DayCumQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayCumQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DayCumQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DayCumQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DayCumQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DayCumQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DayCumQty *)new FIX::DayCumQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DayCumQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayCumQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DayCumQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DayCumQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DayCumQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DayCumQty::DayCumQty()\n"
    "    FIX::DayCumQty::DayCumQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DayCumQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DayCumQty *arg1 = (FIX::DayCumQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DayCumQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DayCumQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DayCumQty" "', argument " "1"" of type '" "FIX::DayCumQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DayCumQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentAcctNum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecuritySettlAgentAcctNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecuritySettlAgentAcctNum")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecuritySettlAgentAcctNum *)new FIX::SecuritySettlAgentAcctNum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecuritySettlAgentAcctNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentAcctNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecuritySettlAgentAcctNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecuritySettlAgentAcctNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecuritySettlAgentAcctNum" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecuritySettlAgentAcctNum" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecuritySettlAgentAcctNum *)new FIX::SecuritySettlAgentAcctNum((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecuritySettlAgentAcctNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentAcctNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecuritySettlAgentAcctNum__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecuritySettlAgentAcctNum__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecuritySettlAgentAcctNum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecuritySettlAgentAcctNum::SecuritySettlAgentAcctNum()\n"
    "    FIX::SecuritySettlAgentAcctNum::SecuritySettlAgentAcctNum(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecuritySettlAgentAcctNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecuritySettlAgentAcctNum *arg1 = (FIX::SecuritySettlAgentAcctNum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecuritySettlAgentAcctNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecuritySettlAgentAcctNum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecuritySettlAgentAcctNum" "', argument " "1"" of type '" "FIX::SecuritySettlAgentAcctNum *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecuritySettlAgentAcctNum * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCurrency *)new FIX::LegCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCurrency *)new FIX::LegCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegCurrency::LegCurrency()\n"
    "    FIX::LegCurrency::LegCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCurrency *arg1 = (FIX::LegCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegCurrency" "', argument " "1"" of type '" "FIX::LegCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncryptedNewPassword__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncryptedNewPassword *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncryptedNewPassword")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncryptedNewPassword *)new FIX::EncryptedNewPassword();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncryptedNewPassword, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedNewPassword__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncryptedNewPassword *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncryptedNewPassword",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncryptedNewPassword" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncryptedNewPassword" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncryptedNewPassword *)new FIX::EncryptedNewPassword((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncryptedNewPassword, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedNewPassword(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncryptedNewPassword__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncryptedNewPassword__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncryptedNewPassword'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncryptedNewPassword::EncryptedNewPassword()\n"
    "    FIX::EncryptedNewPassword::EncryptedNewPassword(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncryptedNewPassword(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncryptedNewPassword *arg1 = (FIX::EncryptedNewPassword *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncryptedNewPassword",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncryptedNewPassword, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncryptedNewPassword" "', argument " "1"" of type '" "FIX::EncryptedNewPassword *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncryptedNewPassword * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeMinPriceIncrementAmount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeMinPriceIncrementAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeMinPriceIncrementAmount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeMinPriceIncrementAmount *)new FIX::DerivativeMinPriceIncrementAmount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeMinPriceIncrementAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMinPriceIncrementAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeMinPriceIncrementAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeMinPriceIncrementAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeMinPriceIncrementAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeMinPriceIncrementAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeMinPriceIncrementAmount *)new FIX::DerivativeMinPriceIncrementAmount((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeMinPriceIncrementAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMinPriceIncrementAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeMinPriceIncrementAmount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeMinPriceIncrementAmount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeMinPriceIncrementAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeMinPriceIncrementAmount::DerivativeMinPriceIncrementAmount()\n"
    "    FIX::DerivativeMinPriceIncrementAmount::DerivativeMinPriceIncrementAmount(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeMinPriceIncrementAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeMinPriceIncrementAmount *arg1 = (FIX::DerivativeMinPriceIncrementAmount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeMinPriceIncrementAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeMinPriceIncrementAmount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeMinPriceIncrementAmount" "', argument " "1"" of type '" "FIX::DerivativeMinPriceIncrementAmount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeMinPriceIncrementAmount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoNested3PartySubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNested3PartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoNested3PartySubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNested3PartySubIDs *)new FIX::NoNested3PartySubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNested3PartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested3PartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoNested3PartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoNested3PartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoNested3PartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoNested3PartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNested3PartySubIDs *)new FIX::NoNested3PartySubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNested3PartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested3PartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoNested3PartySubIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNested3PartySubIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoNested3PartySubIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoNested3PartySubIDs::NoNested3PartySubIDs()\n"
    "    FIX::NoNested3PartySubIDs::NoNested3PartySubIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoNested3PartySubIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNested3PartySubIDs *arg1 = (FIX::NoNested3PartySubIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoNested3PartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoNested3PartySubIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoNested3PartySubIDs" "', argument " "1"" of type '" "FIX::NoNested3PartySubIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoNested3PartySubIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RefSubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefSubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefSubID *)new FIX::RefSubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefSubID *)new FIX::RefSubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefSubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefSubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefSubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefSubID::RefSubID()\n"
    "    FIX::RefSubID::RefSubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefSubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefSubID *arg1 = (FIX::RefSubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefSubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefSubID" "', argument " "1"" of type '" "FIX::RefSubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefSubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlPartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlPartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlPartyRole *)new FIX::SettlPartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlPartyRole *)new FIX::SettlPartyRole((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlPartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlPartyRole__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlPartyRole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlPartyRole::SettlPartyRole()\n"
    "    FIX::SettlPartyRole::SettlPartyRole(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlPartyRole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlPartyRole *arg1 = (FIX::SettlPartyRole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlPartyRole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlPartyRole" "', argument " "1"" of type '" "FIX::SettlPartyRole *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlPartyRole * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CashDistribAgentName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashDistribAgentName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashDistribAgentName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashDistribAgentName *)new FIX::CashDistribAgentName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashDistribAgentName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashDistribAgentName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashDistribAgentName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashDistribAgentName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashDistribAgentName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashDistribAgentName *)new FIX::CashDistribAgentName((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashDistribAgentName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashDistribAgentName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashDistribAgentName__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashDistribAgentName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashDistribAgentName::CashDistribAgentName()\n"
    "    FIX::CashDistribAgentName::CashDistribAgentName(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashDistribAgentName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashDistribAgentName *arg1 = (FIX::CashDistribAgentName *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashDistribAgentName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashDistribAgentName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashDistribAgentName" "', argument " "1"" of type '" "FIX::CashDistribAgentName *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashDistribAgentName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegContractMultiplier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegContractMultiplier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegContractMultiplier")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegContractMultiplier *)new FIX::LegContractMultiplier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegContractMultiplier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegContractMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegContractMultiplier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegContractMultiplier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegContractMultiplier *)new FIX::LegContractMultiplier((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegContractMultiplier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegContractMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegContractMultiplier__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegContractMultiplier__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegContractMultiplier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegContractMultiplier::LegContractMultiplier()\n"
    "    FIX::LegContractMultiplier::LegContractMultiplier(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegContractMultiplier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegContractMultiplier *arg1 = (FIX::LegContractMultiplier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegContractMultiplier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegContractMultiplier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegContractMultiplier" "', argument " "1"" of type '" "FIX::LegContractMultiplier *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegContractMultiplier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ProgPeriodInterval__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ProgPeriodInterval *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ProgPeriodInterval")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ProgPeriodInterval *)new FIX::ProgPeriodInterval();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ProgPeriodInterval, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProgPeriodInterval__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ProgPeriodInterval *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ProgPeriodInterval",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ProgPeriodInterval" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ProgPeriodInterval" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ProgPeriodInterval *)new FIX::ProgPeriodInterval((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ProgPeriodInterval, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProgPeriodInterval(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ProgPeriodInterval__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ProgPeriodInterval__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ProgPeriodInterval'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ProgPeriodInterval::ProgPeriodInterval()\n"
    "    FIX::ProgPeriodInterval::ProgPeriodInterval(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ProgPeriodInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ProgPeriodInterval *arg1 = (FIX::ProgPeriodInterval *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ProgPeriodInterval",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ProgPeriodInterval, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ProgPeriodInterval" "', argument " "1"" of type '" "FIX::ProgPeriodInterval *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ProgPeriodInterval * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegSettlType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSettlType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSettlType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSettlType *)new FIX::LegSettlType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSettlType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSettlType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSettlType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSettlType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSettlType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSettlType *)new FIX::LegSettlType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSettlType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSettlType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSettlType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSettlType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSettlType::LegSettlType()\n"
    "    FIX::LegSettlType::LegSettlType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSettlType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSettlType *arg1 = (FIX::LegSettlType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSettlType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSettlType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSettlType" "', argument " "1"" of type '" "FIX::LegSettlType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSettlType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OnBehalfOfLocationID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OnBehalfOfLocationID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OnBehalfOfLocationID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OnBehalfOfLocationID *)new FIX::OnBehalfOfLocationID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OnBehalfOfLocationID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfLocationID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OnBehalfOfLocationID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OnBehalfOfLocationID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OnBehalfOfLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OnBehalfOfLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OnBehalfOfLocationID *)new FIX::OnBehalfOfLocationID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OnBehalfOfLocationID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfLocationID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OnBehalfOfLocationID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OnBehalfOfLocationID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OnBehalfOfLocationID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OnBehalfOfLocationID::OnBehalfOfLocationID()\n"
    "    FIX::OnBehalfOfLocationID::OnBehalfOfLocationID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OnBehalfOfLocationID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OnBehalfOfLocationID *arg1 = (FIX::OnBehalfOfLocationID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OnBehalfOfLocationID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OnBehalfOfLocationID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OnBehalfOfLocationID" "', argument " "1"" of type '" "FIX::OnBehalfOfLocationID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OnBehalfOfLocationID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OnBehalfOfSubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OnBehalfOfSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OnBehalfOfSubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OnBehalfOfSubID *)new FIX::OnBehalfOfSubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OnBehalfOfSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OnBehalfOfSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OnBehalfOfSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OnBehalfOfSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OnBehalfOfSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OnBehalfOfSubID *)new FIX::OnBehalfOfSubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OnBehalfOfSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OnBehalfOfSubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OnBehalfOfSubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OnBehalfOfSubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OnBehalfOfSubID::OnBehalfOfSubID()\n"
    "    FIX::OnBehalfOfSubID::OnBehalfOfSubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OnBehalfOfSubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OnBehalfOfSubID *arg1 = (FIX::OnBehalfOfSubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OnBehalfOfSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OnBehalfOfSubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OnBehalfOfSubID" "', argument " "1"" of type '" "FIX::OnBehalfOfSubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OnBehalfOfSubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ComplexEventEndTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventEndTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ComplexEventEndTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventEndTime *)new FIX::ComplexEventEndTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventEndTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventEndTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMEONLY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ComplexEventEndTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ComplexEventEndTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMEONLY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexEventEndTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplexEventEndTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMEONLY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventEndTime *)new FIX::ComplexEventEndTime((FIX::UTCTIMEONLY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventEndTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventEndTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ComplexEventEndTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventEndTime__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ComplexEventEndTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ComplexEventEndTime::ComplexEventEndTime()\n"
    "    FIX::ComplexEventEndTime::ComplexEventEndTime(FIX::UTCTIMEONLY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ComplexEventEndTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventEndTime *arg1 = (FIX::ComplexEventEndTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ComplexEventEndTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ComplexEventEndTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComplexEventEndTime" "', argument " "1"" of type '" "FIX::ComplexEventEndTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ComplexEventEndTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RateSourceType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RateSourceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RateSourceType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RateSourceType *)new FIX::RateSourceType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RateSourceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateSourceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RateSourceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RateSourceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RateSourceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RateSourceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RateSourceType *)new FIX::RateSourceType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RateSourceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateSourceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RateSourceType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RateSourceType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RateSourceType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RateSourceType::RateSourceType()\n"
    "    FIX::RateSourceType::RateSourceType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RateSourceType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RateSourceType *arg1 = (FIX::RateSourceType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RateSourceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RateSourceType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RateSourceType" "', argument " "1"" of type '" "FIX::RateSourceType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RateSourceType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeStateOrProvinceOfIssue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeStateOrProvinceOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeStateOrProvinceOfIssue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeStateOrProvinceOfIssue *)new FIX::DerivativeStateOrProvinceOfIssue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeStateOrProvinceOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStateOrProvinceOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeStateOrProvinceOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeStateOrProvinceOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeStateOrProvinceOfIssue *)new FIX::DerivativeStateOrProvinceOfIssue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeStateOrProvinceOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStateOrProvinceOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeStateOrProvinceOfIssue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeStateOrProvinceOfIssue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeStateOrProvinceOfIssue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeStateOrProvinceOfIssue::DerivativeStateOrProvinceOfIssue()\n"
    "    FIX::DerivativeStateOrProvinceOfIssue::DerivativeStateOrProvinceOfIssue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeStateOrProvinceOfIssue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeStateOrProvinceOfIssue *arg1 = (FIX::DerivativeStateOrProvinceOfIssue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeStateOrProvinceOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeStateOrProvinceOfIssue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::DerivativeStateOrProvinceOfIssue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeStateOrProvinceOfIssue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradeLegRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeLegRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeLegRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeLegRefID *)new FIX::TradeLegRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeLegRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeLegRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeLegRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeLegRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeLegRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeLegRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeLegRefID *)new FIX::TradeLegRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeLegRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeLegRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeLegRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeLegRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeLegRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeLegRefID::TradeLegRefID()\n"
    "    FIX::TradeLegRefID::TradeLegRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeLegRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeLegRefID *arg1 = (FIX::TradeLegRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeLegRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeLegRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeLegRefID" "', argument " "1"" of type '" "FIX::TradeLegRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeLegRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RelSymTransactTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelSymTransactTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RelSymTransactTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelSymTransactTime *)new FIX::RelSymTransactTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelSymTransactTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelSymTransactTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RelSymTransactTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelSymTransactTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RelSymTransactTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelSymTransactTime *)new FIX::RelSymTransactTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelSymTransactTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelSymTransactTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RelSymTransactTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelSymTransactTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelSymTransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelSymTransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelSymTransactTime *)new FIX::RelSymTransactTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelSymTransactTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelSymTransactTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::RelSymTransactTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_RelSymTransactTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelSymTransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelSymTransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RelSymTransactTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelSymTransactTime *)new FIX::RelSymTransactTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelSymTransactTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelSymTransactTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RelSymTransactTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelSymTransactTime__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_RelSymTransactTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_RelSymTransactTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RelSymTransactTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RelSymTransactTime::RelSymTransactTime()\n"
    "    FIX::RelSymTransactTime::RelSymTransactTime(bool)\n"
    "    FIX::RelSymTransactTime::RelSymTransactTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::RelSymTransactTime::RelSymTransactTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RelSymTransactTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelSymTransactTime *arg1 = (FIX::RelSymTransactTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RelSymTransactTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RelSymTransactTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelSymTransactTime" "', argument " "1"" of type '" "FIX::RelSymTransactTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RelSymTransactTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoComplexEventTimes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoComplexEventTimes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoComplexEventTimes")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoComplexEventTimes *)new FIX::NoComplexEventTimes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoComplexEventTimes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoComplexEventTimes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoComplexEventTimes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoComplexEventTimes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoComplexEventTimes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoComplexEventTimes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoComplexEventTimes *)new FIX::NoComplexEventTimes((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoComplexEventTimes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoComplexEventTimes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoComplexEventTimes__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoComplexEventTimes__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoComplexEventTimes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoComplexEventTimes::NoComplexEventTimes()\n"
    "    FIX::NoComplexEventTimes::NoComplexEventTimes(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoComplexEventTimes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoComplexEventTimes *arg1 = (FIX::NoComplexEventTimes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoComplexEventTimes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoComplexEventTimes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoComplexEventTimes" "', argument " "1"" of type '" "FIX::NoComplexEventTimes *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoComplexEventTimes * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegCalculatedCcyLastQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCalculatedCcyLastQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegCalculatedCcyLastQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCalculatedCcyLastQty *)new FIX::LegCalculatedCcyLastQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCalculatedCcyLastQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCalculatedCcyLastQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegCalculatedCcyLastQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegCalculatedCcyLastQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegCalculatedCcyLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegCalculatedCcyLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCalculatedCcyLastQty *)new FIX::LegCalculatedCcyLastQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCalculatedCcyLastQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCalculatedCcyLastQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegCalculatedCcyLastQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCalculatedCcyLastQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegCalculatedCcyLastQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegCalculatedCcyLastQty::LegCalculatedCcyLastQty()\n"
    "    FIX::LegCalculatedCcyLastQty::LegCalculatedCcyLastQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegCalculatedCcyLastQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCalculatedCcyLastQty *arg1 = (FIX::LegCalculatedCcyLastQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegCalculatedCcyLastQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegCalculatedCcyLastQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegCalculatedCcyLastQty" "', argument " "1"" of type '" "FIX::LegCalculatedCcyLastQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegCalculatedCcyLastQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Nested3PartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested3PartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested3PartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested3PartyIDSource *)new FIX::Nested3PartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested3PartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested3PartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested3PartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested3PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested3PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested3PartyIDSource *)new FIX::Nested3PartyIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested3PartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested3PartyIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested3PartyIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested3PartyIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested3PartyIDSource::Nested3PartyIDSource()\n"
    "    FIX::Nested3PartyIDSource::Nested3PartyIDSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested3PartyIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested3PartyIDSource *arg1 = (FIX::Nested3PartyIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested3PartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested3PartyIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested3PartyIDSource" "', argument " "1"" of type '" "FIX::Nested3PartyIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested3PartyIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DatedDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DatedDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DatedDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DatedDate *)new FIX::DatedDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DatedDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatedDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DatedDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DatedDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DatedDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DatedDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DatedDate *)new FIX::DatedDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DatedDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DatedDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DatedDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DatedDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DatedDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DatedDate::DatedDate()\n"
    "    FIX::DatedDate::DatedDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DatedDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DatedDate *arg1 = (FIX::DatedDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DatedDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DatedDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DatedDate" "', argument " "1"" of type '" "FIX::DatedDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DatedDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlInstID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlInstID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstID *)new FIX::SettlInstID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlInstID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlInstID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlInstID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlInstID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstID *)new FIX::SettlInstID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlInstID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlInstID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlInstID::SettlInstID()\n"
    "    FIX::SettlInstID::SettlInstID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlInstID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstID *arg1 = (FIX::SettlInstID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlInstID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlInstID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlInstID" "', argument " "1"" of type '" "FIX::SettlInstID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlInstID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OpenInterest__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OpenInterest *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OpenInterest")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OpenInterest *)new FIX::OpenInterest();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OpenInterest, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenInterest__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OpenInterest *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OpenInterest",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OpenInterest" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OpenInterest" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OpenInterest *)new FIX::OpenInterest((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OpenInterest, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenInterest(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OpenInterest__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OpenInterest__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OpenInterest'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OpenInterest::OpenInterest()\n"
    "    FIX::OpenInterest::OpenInterest(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OpenInterest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OpenInterest *arg1 = (FIX::OpenInterest *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OpenInterest",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OpenInterest, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OpenInterest" "', argument " "1"" of type '" "FIX::OpenInterest *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OpenInterest * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingContractMultiplier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingContractMultiplier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingContractMultiplier")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingContractMultiplier *)new FIX::UnderlyingContractMultiplier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingContractMultiplier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingContractMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingContractMultiplier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingContractMultiplier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingContractMultiplier *)new FIX::UnderlyingContractMultiplier((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingContractMultiplier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingContractMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingContractMultiplier__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingContractMultiplier__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingContractMultiplier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingContractMultiplier::UnderlyingContractMultiplier()\n"
    "    FIX::UnderlyingContractMultiplier::UnderlyingContractMultiplier(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingContractMultiplier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingContractMultiplier *arg1 = (FIX::UnderlyingContractMultiplier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingContractMultiplier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingContractMultiplier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingContractMultiplier" "', argument " "1"" of type '" "FIX::UnderlyingContractMultiplier *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingContractMultiplier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TotQuoteEntries__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotQuoteEntries *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotQuoteEntries")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotQuoteEntries *)new FIX::TotQuoteEntries();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotQuoteEntries, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotQuoteEntries__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotQuoteEntries *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotQuoteEntries",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotQuoteEntries" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotQuoteEntries" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotQuoteEntries *)new FIX::TotQuoteEntries((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotQuoteEntries, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotQuoteEntries(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotQuoteEntries__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotQuoteEntries__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotQuoteEntries'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotQuoteEntries::TotQuoteEntries()\n"
    "    FIX::TotQuoteEntries::TotQuoteEntries(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotQuoteEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotQuoteEntries *arg1 = (FIX::TotQuoteEntries *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotQuoteEntries",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotQuoteEntries, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotQuoteEntries" "', argument " "1"" of type '" "FIX::TotQuoteEntries *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotQuoteEntries * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TotNoCxldQuotes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoCxldQuotes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotNoCxldQuotes")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoCxldQuotes *)new FIX::TotNoCxldQuotes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoCxldQuotes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoCxldQuotes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotNoCxldQuotes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotNoCxldQuotes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotNoCxldQuotes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotNoCxldQuotes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoCxldQuotes *)new FIX::TotNoCxldQuotes((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoCxldQuotes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoCxldQuotes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotNoCxldQuotes__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoCxldQuotes__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotNoCxldQuotes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotNoCxldQuotes::TotNoCxldQuotes()\n"
    "    FIX::TotNoCxldQuotes::TotNoCxldQuotes(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotNoCxldQuotes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoCxldQuotes *arg1 = (FIX::TotNoCxldQuotes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotNoCxldQuotes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotNoCxldQuotes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotNoCxldQuotes" "', argument " "1"" of type '" "FIX::TotNoCxldQuotes *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotNoCxldQuotes * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AggregatedBook__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AggregatedBook *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AggregatedBook")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AggregatedBook *)new FIX::AggregatedBook();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AggregatedBook, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AggregatedBook__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AggregatedBook *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AggregatedBook",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AggregatedBook" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AggregatedBook" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AggregatedBook *)new FIX::AggregatedBook((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AggregatedBook, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AggregatedBook(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AggregatedBook__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AggregatedBook__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AggregatedBook'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AggregatedBook::AggregatedBook()\n"
    "    FIX::AggregatedBook::AggregatedBook(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AggregatedBook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AggregatedBook *arg1 = (FIX::AggregatedBook *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AggregatedBook",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AggregatedBook, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AggregatedBook" "', argument " "1"" of type '" "FIX::AggregatedBook *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AggregatedBook * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PaymentRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PaymentRef *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PaymentRef")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PaymentRef *)new FIX::PaymentRef();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PaymentRef, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PaymentRef *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PaymentRef",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PaymentRef" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PaymentRef" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PaymentRef *)new FIX::PaymentRef((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PaymentRef, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentRef(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PaymentRef__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PaymentRef__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PaymentRef'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PaymentRef::PaymentRef()\n"
    "    FIX::PaymentRef::PaymentRef(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PaymentRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PaymentRef *arg1 = (FIX::PaymentRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PaymentRef",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PaymentRef, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PaymentRef" "', argument " "1"" of type '" "FIX::PaymentRef *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PaymentRef * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PaymentDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PaymentDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PaymentDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PaymentDate *)new FIX::PaymentDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PaymentDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PaymentDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PaymentDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PaymentDate *)new FIX::PaymentDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PaymentDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PaymentDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PaymentDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PaymentDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PaymentDate::PaymentDate()\n"
    "    FIX::PaymentDate::PaymentDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PaymentDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PaymentDate *arg1 = (FIX::PaymentDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PaymentDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PaymentDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PaymentDate" "', argument " "1"" of type '" "FIX::PaymentDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PaymentDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrderPercent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderPercent *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrderPercent")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderPercent *)new FIX::OrderPercent();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderPercent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderPercent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrderPercent *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrderPercent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrderPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrderPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderPercent *)new FIX::OrderPercent((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderPercent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderPercent(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrderPercent__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderPercent__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrderPercent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrderPercent::OrderPercent()\n"
    "    FIX::OrderPercent::OrderPercent(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrderPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderPercent *arg1 = (FIX::OrderPercent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrderPercent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrderPercent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrderPercent" "', argument " "1"" of type '" "FIX::OrderPercent *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrderPercent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PosQtyStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosQtyStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PosQtyStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosQtyStatus *)new FIX::PosQtyStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosQtyStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosQtyStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PosQtyStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PosQtyStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PosQtyStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PosQtyStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosQtyStatus *)new FIX::PosQtyStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosQtyStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosQtyStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PosQtyStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosQtyStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PosQtyStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PosQtyStatus::PosQtyStatus()\n"
    "    FIX::PosQtyStatus::PosQtyStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PosQtyStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosQtyStatus *arg1 = (FIX::PosQtyStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PosQtyStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PosQtyStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PosQtyStatus" "', argument " "1"" of type '" "FIX::PosQtyStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PosQtyStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoNested4PartySubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNested4PartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoNested4PartySubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNested4PartySubIDs *)new FIX::NoNested4PartySubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNested4PartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested4PartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoNested4PartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoNested4PartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoNested4PartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoNested4PartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNested4PartySubIDs *)new FIX::NoNested4PartySubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNested4PartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested4PartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoNested4PartySubIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNested4PartySubIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoNested4PartySubIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoNested4PartySubIDs::NoNested4PartySubIDs()\n"
    "    FIX::NoNested4PartySubIDs::NoNested4PartySubIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoNested4PartySubIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNested4PartySubIDs *arg1 = (FIX::NoNested4PartySubIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoNested4PartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoNested4PartySubIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoNested4PartySubIDs" "', argument " "1"" of type '" "FIX::NoNested4PartySubIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoNested4PartySubIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PrivateQuote__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PrivateQuote *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PrivateQuote")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PrivateQuote *)new FIX::PrivateQuote();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PrivateQuote, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PrivateQuote__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PrivateQuote *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PrivateQuote",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PrivateQuote" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PrivateQuote" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PrivateQuote *)new FIX::PrivateQuote((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PrivateQuote, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PrivateQuote(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PrivateQuote__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PrivateQuote__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PrivateQuote'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PrivateQuote::PrivateQuote()\n"
    "    FIX::PrivateQuote::PrivateQuote(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PrivateQuote(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PrivateQuote *arg1 = (FIX::PrivateQuote *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PrivateQuote",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PrivateQuote, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PrivateQuote" "', argument " "1"" of type '" "FIX::PrivateQuote *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PrivateQuote * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecondaryTradeID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryTradeID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryTradeID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryTradeID *)new FIX::SecondaryTradeID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryTradeID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradeID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryTradeID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryTradeID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryTradeID *)new FIX::SecondaryTradeID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryTradeID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradeID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryTradeID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryTradeID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryTradeID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryTradeID::SecondaryTradeID()\n"
    "    FIX::SecondaryTradeID::SecondaryTradeID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryTradeID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryTradeID *arg1 = (FIX::SecondaryTradeID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryTradeID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryTradeID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryTradeID" "', argument " "1"" of type '" "FIX::SecondaryTradeID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryTradeID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentContactPhone__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecuritySettlAgentContactPhone *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecuritySettlAgentContactPhone")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecuritySettlAgentContactPhone *)new FIX::SecuritySettlAgentContactPhone();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecuritySettlAgentContactPhone, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentContactPhone__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecuritySettlAgentContactPhone *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecuritySettlAgentContactPhone",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecuritySettlAgentContactPhone" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecuritySettlAgentContactPhone" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecuritySettlAgentContactPhone *)new FIX::SecuritySettlAgentContactPhone((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecuritySettlAgentContactPhone, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentContactPhone(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecuritySettlAgentContactPhone__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecuritySettlAgentContactPhone__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecuritySettlAgentContactPhone'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecuritySettlAgentContactPhone::SecuritySettlAgentContactPhone()\n"
    "    FIX::SecuritySettlAgentContactPhone::SecuritySettlAgentContactPhone(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecuritySettlAgentContactPhone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecuritySettlAgentContactPhone *arg1 = (FIX::SecuritySettlAgentContactPhone *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecuritySettlAgentContactPhone",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecuritySettlAgentContactPhone, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecuritySettlAgentContactPhone" "', argument " "1"" of type '" "FIX::SecuritySettlAgentContactPhone *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecuritySettlAgentContactPhone * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedMktSegmDescLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedMktSegmDescLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedMktSegmDescLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedMktSegmDescLen *)new FIX::EncodedMktSegmDescLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedMktSegmDescLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedMktSegmDescLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedMktSegmDescLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedMktSegmDescLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedMktSegmDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedMktSegmDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedMktSegmDescLen *)new FIX::EncodedMktSegmDescLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedMktSegmDescLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedMktSegmDescLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedMktSegmDescLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedMktSegmDescLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedMktSegmDescLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedMktSegmDescLen::EncodedMktSegmDescLen()\n"
    "    FIX::EncodedMktSegmDescLen::EncodedMktSegmDescLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedMktSegmDescLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedMktSegmDescLen *arg1 = (FIX::EncodedMktSegmDescLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedMktSegmDescLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedMktSegmDescLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedMktSegmDescLen" "', argument " "1"" of type '" "FIX::EncodedMktSegmDescLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedMktSegmDescLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SideCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideCurrency *)new FIX::SideCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideCurrency *)new FIX::SideCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideCurrency::SideCurrency()\n"
    "    FIX::SideCurrency::SideCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideCurrency *arg1 = (FIX::SideCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideCurrency" "', argument " "1"" of type '" "FIX::SideCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegQty *)new FIX::LegQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegQty *)new FIX::LegQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegQty::LegQty()\n"
    "    FIX::LegQty::LegQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegQty *arg1 = (FIX::LegQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegQty" "', argument " "1"" of type '" "FIX::LegQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MsgType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MsgType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MsgType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MsgType *)new FIX::MsgType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MsgType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MsgType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MsgType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MsgType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MsgType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MsgType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MsgType *)new FIX::MsgType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MsgType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MsgType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MsgType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MsgType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MsgType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MsgType::MsgType()\n"
    "    FIX::MsgType::MsgType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MsgType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MsgType *arg1 = (FIX::MsgType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MsgType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MsgType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MsgType" "', argument " "1"" of type '" "FIX::MsgType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MsgType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoTradingSessions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTradingSessions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoTradingSessions")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTradingSessions *)new FIX::NoTradingSessions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTradingSessions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTradingSessions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoTradingSessions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoTradingSessions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoTradingSessions" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoTradingSessions" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTradingSessions *)new FIX::NoTradingSessions((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTradingSessions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTradingSessions(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoTradingSessions__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTradingSessions__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoTradingSessions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoTradingSessions::NoTradingSessions()\n"
    "    FIX::NoTradingSessions::NoTradingSessions(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoTradingSessions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTradingSessions *arg1 = (FIX::NoTradingSessions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoTradingSessions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoTradingSessions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoTradingSessions" "', argument " "1"" of type '" "FIX::NoTradingSessions *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoTradingSessions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_IOIid__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIid *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IOIid")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIid *)new FIX::IOIid();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIid, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIid__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IOIid *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IOIid",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOIid" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IOIid" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIid *)new FIX::IOIid((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIid, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIid(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IOIid__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIid__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IOIid'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IOIid::IOIid()\n"
    "    FIX::IOIid::IOIid(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IOIid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIid *arg1 = (FIX::IOIid *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IOIid",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IOIid, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOIid" "', argument " "1"" of type '" "FIX::IOIid *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IOIid * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MultiLegReportingType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MultiLegReportingType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MultiLegReportingType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MultiLegReportingType *)new FIX::MultiLegReportingType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MultiLegReportingType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultiLegReportingType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MultiLegReportingType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MultiLegReportingType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MultiLegReportingType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MultiLegReportingType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MultiLegReportingType *)new FIX::MultiLegReportingType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MultiLegReportingType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultiLegReportingType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MultiLegReportingType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MultiLegReportingType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MultiLegReportingType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MultiLegReportingType::MultiLegReportingType()\n"
    "    FIX::MultiLegReportingType::MultiLegReportingType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MultiLegReportingType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MultiLegReportingType *arg1 = (FIX::MultiLegReportingType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MultiLegReportingType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MultiLegReportingType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MultiLegReportingType" "', argument " "1"" of type '" "FIX::MultiLegReportingType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MultiLegReportingType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_IDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IDSource *)new FIX::IDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IDSource *)new FIX::IDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IDSource::IDSource()\n"
    "    FIX::IDSource::IDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IDSource *arg1 = (FIX::IDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IDSource" "', argument " "1"" of type '" "FIX::IDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegStipulationType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegStipulationType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegStipulationType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegStipulationType *)new FIX::LegStipulationType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegStipulationType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStipulationType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegStipulationType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegStipulationType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegStipulationType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegStipulationType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegStipulationType *)new FIX::LegStipulationType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegStipulationType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStipulationType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegStipulationType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegStipulationType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegStipulationType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegStipulationType::LegStipulationType()\n"
    "    FIX::LegStipulationType::LegStipulationType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegStipulationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegStipulationType *arg1 = (FIX::LegStipulationType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegStipulationType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegStipulationType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegStipulationType" "', argument " "1"" of type '" "FIX::LegStipulationType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegStipulationType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeContractMultiplierUnit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeContractMultiplierUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeContractMultiplierUnit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeContractMultiplierUnit *)new FIX::DerivativeContractMultiplierUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeContractMultiplierUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeContractMultiplierUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeContractMultiplierUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeContractMultiplierUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeContractMultiplierUnit *)new FIX::DerivativeContractMultiplierUnit((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeContractMultiplierUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeContractMultiplierUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeContractMultiplierUnit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeContractMultiplierUnit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeContractMultiplierUnit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeContractMultiplierUnit::DerivativeContractMultiplierUnit()\n"
    "    FIX::DerivativeContractMultiplierUnit::DerivativeContractMultiplierUnit(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeContractMultiplierUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeContractMultiplierUnit *arg1 = (FIX::DerivativeContractMultiplierUnit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeContractMultiplierUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeContractMultiplierUnit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeContractMultiplierUnit" "', argument " "1"" of type '" "FIX::DerivativeContractMultiplierUnit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeContractMultiplierUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MarketSegmentID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarketSegmentID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MarketSegmentID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarketSegmentID *)new FIX::MarketSegmentID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarketSegmentID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketSegmentID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MarketSegmentID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MarketSegmentID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarketSegmentID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarketSegmentID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarketSegmentID *)new FIX::MarketSegmentID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarketSegmentID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketSegmentID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MarketSegmentID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarketSegmentID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarketSegmentID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MarketSegmentID::MarketSegmentID()\n"
    "    FIX::MarketSegmentID::MarketSegmentID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MarketSegmentID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarketSegmentID *arg1 = (FIX::MarketSegmentID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MarketSegmentID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MarketSegmentID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarketSegmentID" "', argument " "1"" of type '" "FIX::MarketSegmentID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MarketSegmentID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrdStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrdStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrdStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrdStatus *)new FIX::OrdStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrdStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrdStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrdStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrdStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrdStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrdStatus *)new FIX::OrdStatus((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrdStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrdStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrdStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrdStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrdStatus::OrdStatus()\n"
    "    FIX::OrdStatus::OrdStatus(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrdStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrdStatus *arg1 = (FIX::OrdStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrdStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrdStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrdStatus" "', argument " "1"" of type '" "FIX::OrdStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrdStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MaturityDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaturityDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityDate *)new FIX::MaturityDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaturityDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaturityDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityDate *)new FIX::MaturityDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaturityDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaturityDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaturityDate::MaturityDate()\n"
    "    FIX::MaturityDate::MaturityDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaturityDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityDate *arg1 = (FIX::MaturityDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaturityDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaturityDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaturityDate" "', argument " "1"" of type '" "FIX::MaturityDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaturityDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ApplTotalMessageCount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplTotalMessageCount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplTotalMessageCount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplTotalMessageCount *)new FIX::ApplTotalMessageCount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplTotalMessageCount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplTotalMessageCount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplTotalMessageCount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplTotalMessageCount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplTotalMessageCount" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplTotalMessageCount" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplTotalMessageCount *)new FIX::ApplTotalMessageCount((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplTotalMessageCount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplTotalMessageCount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplTotalMessageCount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplTotalMessageCount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplTotalMessageCount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplTotalMessageCount::ApplTotalMessageCount()\n"
    "    FIX::ApplTotalMessageCount::ApplTotalMessageCount(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplTotalMessageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplTotalMessageCount *arg1 = (FIX::ApplTotalMessageCount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplTotalMessageCount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplTotalMessageCount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplTotalMessageCount" "', argument " "1"" of type '" "FIX::ApplTotalMessageCount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplTotalMessageCount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_InstrumentPartySubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrumentPartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InstrumentPartySubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrumentPartySubID *)new FIX::InstrumentPartySubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrumentPartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InstrumentPartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InstrumentPartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrumentPartySubID *)new FIX::InstrumentPartySubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrumentPartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InstrumentPartySubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrumentPartySubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InstrumentPartySubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InstrumentPartySubID::InstrumentPartySubID()\n"
    "    FIX::InstrumentPartySubID::InstrumentPartySubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InstrumentPartySubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrumentPartySubID *arg1 = (FIX::InstrumentPartySubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InstrumentPartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InstrumentPartySubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InstrumentPartySubID" "', argument " "1"" of type '" "FIX::InstrumentPartySubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InstrumentPartySubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CustomerOrFirm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CustomerOrFirm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CustomerOrFirm")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CustomerOrFirm *)new FIX::CustomerOrFirm();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CustomerOrFirm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustomerOrFirm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CustomerOrFirm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CustomerOrFirm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomerOrFirm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomerOrFirm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CustomerOrFirm *)new FIX::CustomerOrFirm((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CustomerOrFirm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustomerOrFirm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CustomerOrFirm__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CustomerOrFirm__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CustomerOrFirm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CustomerOrFirm::CustomerOrFirm()\n"
    "    FIX::CustomerOrFirm::CustomerOrFirm(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CustomerOrFirm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CustomerOrFirm *arg1 = (FIX::CustomerOrFirm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CustomerOrFirm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CustomerOrFirm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CustomerOrFirm" "', argument " "1"" of type '" "FIX::CustomerOrFirm *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CustomerOrFirm * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AdjustmentType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AdjustmentType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AdjustmentType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AdjustmentType *)new FIX::AdjustmentType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AdjustmentType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdjustmentType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AdjustmentType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AdjustmentType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AdjustmentType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AdjustmentType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AdjustmentType *)new FIX::AdjustmentType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AdjustmentType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdjustmentType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AdjustmentType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AdjustmentType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AdjustmentType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AdjustmentType::AdjustmentType()\n"
    "    FIX::AdjustmentType::AdjustmentType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AdjustmentType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AdjustmentType *arg1 = (FIX::AdjustmentType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AdjustmentType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AdjustmentType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AdjustmentType" "', argument " "1"" of type '" "FIX::AdjustmentType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AdjustmentType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingInstrumentPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingInstrumentPartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingInstrumentPartyID *)new FIX::UnderlyingInstrumentPartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingInstrumentPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingInstrumentPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingInstrumentPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingInstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingInstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingInstrumentPartyID *)new FIX::UnderlyingInstrumentPartyID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingInstrumentPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingInstrumentPartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingInstrumentPartyID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingInstrumentPartyID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingInstrumentPartyID::UnderlyingInstrumentPartyID()\n"
    "    FIX::UnderlyingInstrumentPartyID::UnderlyingInstrumentPartyID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingInstrumentPartyID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingInstrumentPartyID *arg1 = (FIX::UnderlyingInstrumentPartyID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingInstrumentPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingInstrumentPartyID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingInstrumentPartyID" "', argument " "1"" of type '" "FIX::UnderlyingInstrumentPartyID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingInstrumentPartyID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AsOfIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AsOfIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AsOfIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AsOfIndicator *)new FIX::AsOfIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AsOfIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AsOfIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AsOfIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AsOfIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AsOfIndicator" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AsOfIndicator" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AsOfIndicator *)new FIX::AsOfIndicator((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AsOfIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AsOfIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AsOfIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AsOfIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AsOfIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AsOfIndicator::AsOfIndicator()\n"
    "    FIX::AsOfIndicator::AsOfIndicator(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AsOfIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AsOfIndicator *arg1 = (FIX::AsOfIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AsOfIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AsOfIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AsOfIndicator" "', argument " "1"" of type '" "FIX::AsOfIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AsOfIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_QuoteStatusReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteStatusReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteStatusReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteStatusReqID *)new FIX::QuoteStatusReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteStatusReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteStatusReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteStatusReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteStatusReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteStatusReqID *)new FIX::QuoteStatusReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteStatusReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteStatusReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteStatusReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteStatusReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteStatusReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteStatusReqID::QuoteStatusReqID()\n"
    "    FIX::QuoteStatusReqID::QuoteStatusReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteStatusReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteStatusReqID *arg1 = (FIX::QuoteStatusReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteStatusReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteStatusReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteStatusReqID" "', argument " "1"" of type '" "FIX::QuoteStatusReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteStatusReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegPositionEffect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegPositionEffect *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegPositionEffect")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegPositionEffect *)new FIX::LegPositionEffect();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegPositionEffect, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPositionEffect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegPositionEffect *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegPositionEffect",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegPositionEffect" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegPositionEffect" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegPositionEffect *)new FIX::LegPositionEffect((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegPositionEffect, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPositionEffect(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegPositionEffect__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegPositionEffect__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegPositionEffect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegPositionEffect::LegPositionEffect()\n"
    "    FIX::LegPositionEffect::LegPositionEffect(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegPositionEffect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegPositionEffect *arg1 = (FIX::LegPositionEffect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegPositionEffect",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegPositionEffect, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegPositionEffect" "', argument " "1"" of type '" "FIX::LegPositionEffect *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegPositionEffect * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDEntryPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDEntryPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryPx *)new FIX::MDEntryPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDEntryPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDEntryPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDEntryPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDEntryPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryPx *)new FIX::MDEntryPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDEntryPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDEntryPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDEntryPx::MDEntryPx()\n"
    "    FIX::MDEntryPx::MDEntryPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDEntryPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryPx *arg1 = (FIX::MDEntryPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDEntryPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDEntryPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDEntryPx" "', argument " "1"" of type '" "FIX::MDEntryPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDEntryPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MassActionScope__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassActionScope *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MassActionScope")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassActionScope *)new FIX::MassActionScope();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassActionScope, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionScope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MassActionScope *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MassActionScope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassActionScope" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassActionScope" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassActionScope *)new FIX::MassActionScope((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassActionScope, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionScope(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MassActionScope__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassActionScope__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MassActionScope'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MassActionScope::MassActionScope()\n"
    "    FIX::MassActionScope::MassActionScope(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MassActionScope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassActionScope *arg1 = (FIX::MassActionScope *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MassActionScope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MassActionScope, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MassActionScope" "', argument " "1"" of type '" "FIX::MassActionScope *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MassActionScope * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ReportedPxDiff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ReportedPxDiff *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ReportedPxDiff")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ReportedPxDiff *)new FIX::ReportedPxDiff();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ReportedPxDiff, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReportedPxDiff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ReportedPxDiff *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ReportedPxDiff",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ReportedPxDiff" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ReportedPxDiff" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ReportedPxDiff *)new FIX::ReportedPxDiff((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ReportedPxDiff, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReportedPxDiff(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ReportedPxDiff__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ReportedPxDiff__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ReportedPxDiff'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ReportedPxDiff::ReportedPxDiff()\n"
    "    FIX::ReportedPxDiff::ReportedPxDiff(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ReportedPxDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ReportedPxDiff *arg1 = (FIX::ReportedPxDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ReportedPxDiff",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ReportedPxDiff, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReportedPxDiff" "', argument " "1"" of type '" "FIX::ReportedPxDiff *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ReportedPxDiff * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSettlementDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSettlementDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSettlementDate *)new FIX::UnderlyingSettlementDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSettlementDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSettlementDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSettlementDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSettlementDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSettlementDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSettlementDate *)new FIX::UnderlyingSettlementDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSettlementDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSettlementDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSettlementDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSettlementDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSettlementDate::UnderlyingSettlementDate()\n"
    "    FIX::UnderlyingSettlementDate::UnderlyingSettlementDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSettlementDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSettlementDate *arg1 = (FIX::UnderlyingSettlementDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSettlementDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSettlementDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSettlementDate" "', argument " "1"" of type '" "FIX::UnderlyingSettlementDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSettlementDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoNestedPartySubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNestedPartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoNestedPartySubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNestedPartySubIDs *)new FIX::NoNestedPartySubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNestedPartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNestedPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoNestedPartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoNestedPartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoNestedPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoNestedPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNestedPartySubIDs *)new FIX::NoNestedPartySubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNestedPartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNestedPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoNestedPartySubIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNestedPartySubIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoNestedPartySubIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoNestedPartySubIDs::NoNestedPartySubIDs()\n"
    "    FIX::NoNestedPartySubIDs::NoNestedPartySubIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoNestedPartySubIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNestedPartySubIDs *arg1 = (FIX::NoNestedPartySubIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoNestedPartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoNestedPartySubIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoNestedPartySubIDs" "', argument " "1"" of type '" "FIX::NoNestedPartySubIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoNestedPartySubIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AllocReportRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocReportRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocReportRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocReportRefID *)new FIX::AllocReportRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocReportRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocReportRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocReportRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocReportRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocReportRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocReportRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocReportRefID *)new FIX::AllocReportRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocReportRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocReportRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocReportRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocReportRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocReportRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocReportRefID::AllocReportRefID()\n"
    "    FIX::AllocReportRefID::AllocReportRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocReportRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocReportRefID *arg1 = (FIX::AllocReportRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocReportRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocReportRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocReportRefID" "', argument " "1"" of type '" "FIX::AllocReportRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocReportRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Concession__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Concession *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Concession")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Concession *)new FIX::Concession();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Concession, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Concession__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Concession *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Concession",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Concession" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Concession" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Concession *)new FIX::Concession((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Concession, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Concession(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Concession__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Concession__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Concession'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Concession::Concession()\n"
    "    FIX::Concession::Concession(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Concession(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Concession *arg1 = (FIX::Concession *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Concession",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Concession, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Concession" "', argument " "1"" of type '" "FIX::Concession *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Concession * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedSecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedSecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSecurityDesc *)new FIX::EncodedSecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSecurityDesc *)new FIX::EncodedSecurityDesc((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedSecurityDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedSecurityDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedSecurityDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedSecurityDesc::EncodedSecurityDesc()\n"
    "    FIX::EncodedSecurityDesc::EncodedSecurityDesc(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedSecurityDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedSecurityDesc *arg1 = (FIX::EncodedSecurityDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedSecurityDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedSecurityDesc" "', argument " "1"" of type '" "FIX::EncodedSecurityDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedSecurityDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ExecRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExecRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecRefID *)new FIX::ExecRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExecRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExecRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExecRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExecRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecRefID *)new FIX::ExecRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExecRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExecRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExecRefID::ExecRefID()\n"
    "    FIX::ExecRefID::ExecRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExecRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecRefID *arg1 = (FIX::ExecRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExecRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExecRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExecRefID" "', argument " "1"" of type '" "FIX::ExecRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExecRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_VenueType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::VenueType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VenueType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::VenueType *)new FIX::VenueType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__VenueType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VenueType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::VenueType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VenueType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VenueType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VenueType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::VenueType *)new FIX::VenueType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__VenueType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VenueType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_VenueType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VenueType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VenueType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::VenueType::VenueType()\n"
    "    FIX::VenueType::VenueType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_VenueType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::VenueType *arg1 = (FIX::VenueType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VenueType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__VenueType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VenueType" "', argument " "1"" of type '" "FIX::VenueType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::VenueType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MassActionType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassActionType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MassActionType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassActionType *)new FIX::MassActionType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassActionType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MassActionType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MassActionType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassActionType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassActionType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassActionType *)new FIX::MassActionType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassActionType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MassActionType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassActionType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MassActionType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MassActionType::MassActionType()\n"
    "    FIX::MassActionType::MassActionType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MassActionType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassActionType *arg1 = (FIX::MassActionType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MassActionType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MassActionType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MassActionType" "', argument " "1"" of type '" "FIX::MassActionType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MassActionType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PosMaintResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosMaintResult *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PosMaintResult")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosMaintResult *)new FIX::PosMaintResult();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosMaintResult, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PosMaintResult *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PosMaintResult",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PosMaintResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PosMaintResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosMaintResult *)new FIX::PosMaintResult((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosMaintResult, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintResult(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PosMaintResult__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosMaintResult__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PosMaintResult'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PosMaintResult::PosMaintResult()\n"
    "    FIX::PosMaintResult::PosMaintResult(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PosMaintResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosMaintResult *arg1 = (FIX::PosMaintResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PosMaintResult",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PosMaintResult, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PosMaintResult" "', argument " "1"" of type '" "FIX::PosMaintResult *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PosMaintResult * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_IOIShares__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIShares *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IOIShares")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIShares *)new FIX::IOIShares();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIShares, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIShares__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IOIShares *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IOIShares",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOIShares" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IOIShares" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIShares *)new FIX::IOIShares((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIShares, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIShares(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IOIShares__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIShares__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IOIShares'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IOIShares::IOIShares()\n"
    "    FIX::IOIShares::IOIShares(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IOIShares(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIShares *arg1 = (FIX::IOIShares *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IOIShares",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IOIShares, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOIShares" "', argument " "1"" of type '" "FIX::IOIShares *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IOIShares * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BenchmarkSecurityID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BenchmarkSecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BenchmarkSecurityID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BenchmarkSecurityID *)new FIX::BenchmarkSecurityID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BenchmarkSecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkSecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BenchmarkSecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BenchmarkSecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BenchmarkSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BenchmarkSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BenchmarkSecurityID *)new FIX::BenchmarkSecurityID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BenchmarkSecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BenchmarkSecurityID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BenchmarkSecurityID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BenchmarkSecurityID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BenchmarkSecurityID::BenchmarkSecurityID()\n"
    "    FIX::BenchmarkSecurityID::BenchmarkSecurityID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BenchmarkSecurityID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BenchmarkSecurityID *arg1 = (FIX::BenchmarkSecurityID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BenchmarkSecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BenchmarkSecurityID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BenchmarkSecurityID" "', argument " "1"" of type '" "FIX::BenchmarkSecurityID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BenchmarkSecurityID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegLastQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegLastQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegLastQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegLastQty *)new FIX::LegLastQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegLastQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLastQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegLastQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegLastQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegLastQty *)new FIX::LegLastQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegLastQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLastQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegLastQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegLastQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegLastQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegLastQty::LegLastQty()\n"
    "    FIX::LegLastQty::LegLastQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegLastQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegLastQty *arg1 = (FIX::LegLastQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegLastQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegLastQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegLastQty" "', argument " "1"" of type '" "FIX::LegLastQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegLastQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AllocSettlCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocSettlCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocSettlCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocSettlCurrency *)new FIX::AllocSettlCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocSettlCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocSettlCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocSettlCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocSettlCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocSettlCurrency *)new FIX::AllocSettlCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocSettlCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocSettlCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocSettlCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocSettlCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocSettlCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocSettlCurrency::AllocSettlCurrency()\n"
    "    FIX::AllocSettlCurrency::AllocSettlCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocSettlCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocSettlCurrency *arg1 = (FIX::AllocSettlCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocSettlCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocSettlCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocSettlCurrency" "', argument " "1"" of type '" "FIX::AllocSettlCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocSettlCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegCountryOfIssue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCountryOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegCountryOfIssue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCountryOfIssue *)new FIX::LegCountryOfIssue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCountryOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCountryOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::COUNTRY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegCountryOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegCountryOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__COUNTRY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegCountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegCountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::COUNTRY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCountryOfIssue *)new FIX::LegCountryOfIssue((FIX::COUNTRY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCountryOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCountryOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegCountryOfIssue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__COUNTRY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCountryOfIssue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegCountryOfIssue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegCountryOfIssue::LegCountryOfIssue()\n"
    "    FIX::LegCountryOfIssue::LegCountryOfIssue(FIX::COUNTRY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegCountryOfIssue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCountryOfIssue *arg1 = (FIX::LegCountryOfIssue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegCountryOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegCountryOfIssue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegCountryOfIssue" "', argument " "1"" of type '" "FIX::LegCountryOfIssue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegCountryOfIssue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXML__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityXML *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSecurityXML")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityXML *)new FIX::DerivativeSecurityXML();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityXML, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXML__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSecurityXML *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSecurityXML",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSecurityXML" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSecurityXML" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityXML *)new FIX::DerivativeSecurityXML((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityXML, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXML(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSecurityXML__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityXML__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSecurityXML'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSecurityXML::DerivativeSecurityXML()\n"
    "    FIX::DerivativeSecurityXML::DerivativeSecurityXML(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSecurityXML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityXML *arg1 = (FIX::DerivativeSecurityXML *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSecurityXML",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSecurityXML, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSecurityXML" "', argument " "1"" of type '" "FIX::DerivativeSecurityXML *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSecurityXML * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StrikeRuleID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikeRuleID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StrikeRuleID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeRuleID *)new FIX::StrikeRuleID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeRuleID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeRuleID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrikeRuleID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrikeRuleID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrikeRuleID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrikeRuleID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeRuleID *)new FIX::StrikeRuleID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeRuleID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeRuleID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StrikeRuleID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikeRuleID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StrikeRuleID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StrikeRuleID::StrikeRuleID()\n"
    "    FIX::StrikeRuleID::StrikeRuleID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StrikeRuleID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikeRuleID *arg1 = (FIX::StrikeRuleID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrikeRuleID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StrikeRuleID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrikeRuleID" "', argument " "1"" of type '" "FIX::StrikeRuleID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StrikeRuleID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RefCompID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefCompID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefCompID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefCompID *)new FIX::RefCompID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefCompID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefCompID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefCompID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefCompID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefCompID *)new FIX::RefCompID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefCompID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefCompID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefCompID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefCompID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefCompID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefCompID::RefCompID()\n"
    "    FIX::RefCompID::RefCompID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefCompID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefCompID *arg1 = (FIX::RefCompID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefCompID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefCompID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefCompID" "', argument " "1"" of type '" "FIX::RefCompID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefCompID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlCurrOfferFxRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlCurrOfferFxRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlCurrOfferFxRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlCurrOfferFxRate *)new FIX::SettlCurrOfferFxRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlCurrOfferFxRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrOfferFxRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlCurrOfferFxRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlCurrOfferFxRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlCurrOfferFxRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlCurrOfferFxRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlCurrOfferFxRate *)new FIX::SettlCurrOfferFxRate((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlCurrOfferFxRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrOfferFxRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlCurrOfferFxRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlCurrOfferFxRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlCurrOfferFxRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlCurrOfferFxRate::SettlCurrOfferFxRate()\n"
    "    FIX::SettlCurrOfferFxRate::SettlCurrOfferFxRate(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlCurrOfferFxRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlCurrOfferFxRate *arg1 = (FIX::SettlCurrOfferFxRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlCurrOfferFxRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlCurrOfferFxRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlCurrOfferFxRate" "', argument " "1"" of type '" "FIX::SettlCurrOfferFxRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlCurrOfferFxRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OfferYield__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OfferYield *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OfferYield")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OfferYield *)new FIX::OfferYield();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OfferYield, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferYield__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OfferYield *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OfferYield",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OfferYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OfferYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OfferYield *)new FIX::OfferYield((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OfferYield, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferYield(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OfferYield__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OfferYield__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OfferYield'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OfferYield::OfferYield()\n"
    "    FIX::OfferYield::OfferYield(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OfferYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OfferYield *arg1 = (FIX::OfferYield *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OfferYield",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OfferYield, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OfferYield" "', argument " "1"" of type '" "FIX::OfferYield *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OfferYield * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TargetPartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TargetPartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetPartyIDSource *)new FIX::TargetPartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TargetPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TargetPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TargetPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TargetPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetPartyIDSource *)new FIX::TargetPartyIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TargetPartyIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetPartyIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TargetPartyIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TargetPartyIDSource::TargetPartyIDSource()\n"
    "    FIX::TargetPartyIDSource::TargetPartyIDSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TargetPartyIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetPartyIDSource *arg1 = (FIX::TargetPartyIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TargetPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TargetPartyIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TargetPartyIDSource" "', argument " "1"" of type '" "FIX::TargetPartyIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TargetPartyIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncryptedNewPasswordLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncryptedNewPasswordLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncryptedNewPasswordLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncryptedNewPasswordLen *)new FIX::EncryptedNewPasswordLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncryptedNewPasswordLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedNewPasswordLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncryptedNewPasswordLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncryptedNewPasswordLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncryptedNewPasswordLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncryptedNewPasswordLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncryptedNewPasswordLen *)new FIX::EncryptedNewPasswordLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncryptedNewPasswordLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedNewPasswordLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncryptedNewPasswordLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncryptedNewPasswordLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncryptedNewPasswordLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncryptedNewPasswordLen::EncryptedNewPasswordLen()\n"
    "    FIX::EncryptedNewPasswordLen::EncryptedNewPasswordLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncryptedNewPasswordLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncryptedNewPasswordLen *arg1 = (FIX::EncryptedNewPasswordLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncryptedNewPasswordLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncryptedNewPasswordLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncryptedNewPasswordLen" "', argument " "1"" of type '" "FIX::EncryptedNewPasswordLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncryptedNewPasswordLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoPositions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoPositions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoPositions")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPositions *)new FIX::NoPositions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPositions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPositions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoPositions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoPositions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoPositions" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoPositions" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPositions *)new FIX::NoPositions((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPositions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPositions(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoPositions__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoPositions__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoPositions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoPositions::NoPositions()\n"
    "    FIX::NoPositions::NoPositions(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoPositions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoPositions *arg1 = (FIX::NoPositions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoPositions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoPositions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoPositions" "', argument " "1"" of type '" "FIX::NoPositions *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoPositions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TotalAccruedInterestAmt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalAccruedInterestAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotalAccruedInterestAmt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalAccruedInterestAmt *)new FIX::TotalAccruedInterestAmt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalAccruedInterestAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalAccruedInterestAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotalAccruedInterestAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotalAccruedInterestAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotalAccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotalAccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalAccruedInterestAmt *)new FIX::TotalAccruedInterestAmt((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalAccruedInterestAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalAccruedInterestAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotalAccruedInterestAmt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalAccruedInterestAmt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotalAccruedInterestAmt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotalAccruedInterestAmt::TotalAccruedInterestAmt()\n"
    "    FIX::TotalAccruedInterestAmt::TotalAccruedInterestAmt(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotalAccruedInterestAmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalAccruedInterestAmt *arg1 = (FIX::TotalAccruedInterestAmt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotalAccruedInterestAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotalAccruedInterestAmt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotalAccruedInterestAmt" "', argument " "1"" of type '" "FIX::TotalAccruedInterestAmt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotalAccruedInterestAmt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingOptAttribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingOptAttribute *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingOptAttribute")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingOptAttribute *)new FIX::UnderlyingOptAttribute();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingOptAttribute, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingOptAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingOptAttribute *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingOptAttribute",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingOptAttribute *)new FIX::UnderlyingOptAttribute((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingOptAttribute, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingOptAttribute(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingOptAttribute__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingOptAttribute__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingOptAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingOptAttribute::UnderlyingOptAttribute()\n"
    "    FIX::UnderlyingOptAttribute::UnderlyingOptAttribute(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingOptAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingOptAttribute *arg1 = (FIX::UnderlyingOptAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingOptAttribute",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingOptAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingOptAttribute" "', argument " "1"" of type '" "FIX::UnderlyingOptAttribute *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingOptAttribute * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeInstrAttribValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrAttribValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeInstrAttribValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrAttribValue *)new FIX::DerivativeInstrAttribValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrAttribValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrAttribValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeInstrAttribValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeInstrAttribValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeInstrAttribValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeInstrAttribValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrAttribValue *)new FIX::DerivativeInstrAttribValue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrAttribValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrAttribValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeInstrAttribValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrAttribValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeInstrAttribValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeInstrAttribValue::DerivativeInstrAttribValue()\n"
    "    FIX::DerivativeInstrAttribValue::DerivativeInstrAttribValue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeInstrAttribValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrAttribValue *arg1 = (FIX::DerivativeInstrAttribValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeInstrAttribValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeInstrAttribValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeInstrAttribValue" "', argument " "1"" of type '" "FIX::DerivativeInstrAttribValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeInstrAttribValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_InstrumentPartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrumentPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InstrumentPartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrumentPartyIDSource *)new FIX::InstrumentPartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrumentPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InstrumentPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InstrumentPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrumentPartyIDSource *)new FIX::InstrumentPartyIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrumentPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InstrumentPartyIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrumentPartyIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InstrumentPartyIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InstrumentPartyIDSource::InstrumentPartyIDSource()\n"
    "    FIX::InstrumentPartyIDSource::InstrumentPartyIDSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InstrumentPartyIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrumentPartyIDSource *arg1 = (FIX::InstrumentPartyIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InstrumentPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InstrumentPartyIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::InstrumentPartyIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InstrumentPartyIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PegOffsetType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegOffsetType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PegOffsetType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegOffsetType *)new FIX::PegOffsetType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegOffsetType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegOffsetType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PegOffsetType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PegOffsetType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PegOffsetType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PegOffsetType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegOffsetType *)new FIX::PegOffsetType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegOffsetType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegOffsetType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PegOffsetType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegOffsetType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PegOffsetType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PegOffsetType::PegOffsetType()\n"
    "    FIX::PegOffsetType::PegOffsetType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PegOffsetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegOffsetType *arg1 = (FIX::PegOffsetType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PegOffsetType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PegOffsetType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PegOffsetType" "', argument " "1"" of type '" "FIX::PegOffsetType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PegOffsetType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MassCancelRejectReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassCancelRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MassCancelRejectReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassCancelRejectReason *)new FIX::MassCancelRejectReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassCancelRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassCancelRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MassCancelRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MassCancelRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassCancelRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassCancelRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassCancelRejectReason *)new FIX::MassCancelRejectReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassCancelRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassCancelRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MassCancelRejectReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassCancelRejectReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MassCancelRejectReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MassCancelRejectReason::MassCancelRejectReason()\n"
    "    FIX::MassCancelRejectReason::MassCancelRejectReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MassCancelRejectReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassCancelRejectReason *arg1 = (FIX::MassCancelRejectReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MassCancelRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MassCancelRejectReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MassCancelRejectReason" "', argument " "1"" of type '" "FIX::MassCancelRejectReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MassCancelRejectReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ResponseTransportType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ResponseTransportType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ResponseTransportType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ResponseTransportType *)new FIX::ResponseTransportType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ResponseTransportType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResponseTransportType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ResponseTransportType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResponseTransportType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ResponseTransportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ResponseTransportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ResponseTransportType *)new FIX::ResponseTransportType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ResponseTransportType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResponseTransportType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ResponseTransportType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ResponseTransportType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ResponseTransportType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ResponseTransportType::ResponseTransportType()\n"
    "    FIX::ResponseTransportType::ResponseTransportType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ResponseTransportType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ResponseTransportType *arg1 = (FIX::ResponseTransportType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResponseTransportType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ResponseTransportType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResponseTransportType" "', argument " "1"" of type '" "FIX::ResponseTransportType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ResponseTransportType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegSecurityIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSecurityIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecurityIDSource *)new FIX::LegSecurityIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecurityIDSource *)new FIX::LegSecurityIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSecurityIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecurityIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSecurityIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSecurityIDSource::LegSecurityIDSource()\n"
    "    FIX::LegSecurityIDSource::LegSecurityIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSecurityIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecurityIDSource *arg1 = (FIX::LegSecurityIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSecurityIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSecurityIDSource" "', argument " "1"" of type '" "FIX::LegSecurityIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSecurityIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BasisFeaturePrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BasisFeaturePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BasisFeaturePrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BasisFeaturePrice *)new FIX::BasisFeaturePrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BasisFeaturePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BasisFeaturePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BasisFeaturePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BasisFeaturePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BasisFeaturePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BasisFeaturePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BasisFeaturePrice *)new FIX::BasisFeaturePrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BasisFeaturePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BasisFeaturePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BasisFeaturePrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BasisFeaturePrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BasisFeaturePrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BasisFeaturePrice::BasisFeaturePrice()\n"
    "    FIX::BasisFeaturePrice::BasisFeaturePrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BasisFeaturePrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BasisFeaturePrice *arg1 = (FIX::BasisFeaturePrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BasisFeaturePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BasisFeaturePrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BasisFeaturePrice" "', argument " "1"" of type '" "FIX::BasisFeaturePrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BasisFeaturePrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CouponPaymentDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CouponPaymentDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CouponPaymentDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CouponPaymentDate *)new FIX::CouponPaymentDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CouponPaymentDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CouponPaymentDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CouponPaymentDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CouponPaymentDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CouponPaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CouponPaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CouponPaymentDate *)new FIX::CouponPaymentDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CouponPaymentDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CouponPaymentDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CouponPaymentDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CouponPaymentDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CouponPaymentDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CouponPaymentDate::CouponPaymentDate()\n"
    "    FIX::CouponPaymentDate::CouponPaymentDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CouponPaymentDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CouponPaymentDate *arg1 = (FIX::CouponPaymentDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CouponPaymentDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CouponPaymentDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CouponPaymentDate" "', argument " "1"" of type '" "FIX::CouponPaymentDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CouponPaymentDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradSesStatusRejReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesStatusRejReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradSesStatusRejReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesStatusRejReason *)new FIX::TradSesStatusRejReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesStatusRejReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStatusRejReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesStatusRejReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesStatusRejReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesStatusRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesStatusRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesStatusRejReason *)new FIX::TradSesStatusRejReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesStatusRejReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStatusRejReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradSesStatusRejReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesStatusRejReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradSesStatusRejReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradSesStatusRejReason::TradSesStatusRejReason()\n"
    "    FIX::TradSesStatusRejReason::TradSesStatusRejReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradSesStatusRejReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesStatusRejReason *arg1 = (FIX::TradSesStatusRejReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradSesStatusRejReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradSesStatusRejReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradSesStatusRejReason" "', argument " "1"" of type '" "FIX::TradSesStatusRejReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradSesStatusRejReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingDetachmentPoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingDetachmentPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingDetachmentPoint")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingDetachmentPoint *)new FIX::UnderlyingDetachmentPoint();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingDetachmentPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingDetachmentPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingDetachmentPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingDetachmentPoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingDetachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingDetachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingDetachmentPoint *)new FIX::UnderlyingDetachmentPoint((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingDetachmentPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingDetachmentPoint(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingDetachmentPoint__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingDetachmentPoint__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingDetachmentPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingDetachmentPoint::UnderlyingDetachmentPoint()\n"
    "    FIX::UnderlyingDetachmentPoint::UnderlyingDetachmentPoint(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingDetachmentPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingDetachmentPoint *arg1 = (FIX::UnderlyingDetachmentPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingDetachmentPoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingDetachmentPoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingDetachmentPoint" "', argument " "1"" of type '" "FIX::UnderlyingDetachmentPoint *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingDetachmentPoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MaturityRuleID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityRuleID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaturityRuleID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityRuleID *)new FIX::MaturityRuleID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityRuleID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityRuleID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaturityRuleID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaturityRuleID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaturityRuleID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaturityRuleID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityRuleID *)new FIX::MaturityRuleID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityRuleID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityRuleID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaturityRuleID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityRuleID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaturityRuleID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaturityRuleID::MaturityRuleID()\n"
    "    FIX::MaturityRuleID::MaturityRuleID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaturityRuleID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityRuleID *arg1 = (FIX::MaturityRuleID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaturityRuleID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaturityRuleID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaturityRuleID" "', argument " "1"" of type '" "FIX::MaturityRuleID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaturityRuleID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingRepoCollateralSecurityType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingRepoCollateralSecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingRepoCollateralSecurityType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingRepoCollateralSecurityType *)new FIX::UnderlyingRepoCollateralSecurityType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingRepoCollateralSecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRepoCollateralSecurityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingRepoCollateralSecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingRepoCollateralSecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingRepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingRepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingRepoCollateralSecurityType *)new FIX::UnderlyingRepoCollateralSecurityType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingRepoCollateralSecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRepoCollateralSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingRepoCollateralSecurityType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingRepoCollateralSecurityType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingRepoCollateralSecurityType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingRepoCollateralSecurityType::UnderlyingRepoCollateralSecurityType()\n"
    "    FIX::UnderlyingRepoCollateralSecurityType::UnderlyingRepoCollateralSecurityType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingRepoCollateralSecurityType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingRepoCollateralSecurityType *arg1 = (FIX::UnderlyingRepoCollateralSecurityType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingRepoCollateralSecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingRepoCollateralSecurityType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingRepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::UnderlyingRepoCollateralSecurityType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingRepoCollateralSecurityType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoTimeInForceRules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTimeInForceRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoTimeInForceRules")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTimeInForceRules *)new FIX::NoTimeInForceRules();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTimeInForceRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTimeInForceRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoTimeInForceRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoTimeInForceRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoTimeInForceRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoTimeInForceRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTimeInForceRules *)new FIX::NoTimeInForceRules((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTimeInForceRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTimeInForceRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoTimeInForceRules__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTimeInForceRules__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoTimeInForceRules'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoTimeInForceRules::NoTimeInForceRules()\n"
    "    FIX::NoTimeInForceRules::NoTimeInForceRules(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoTimeInForceRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTimeInForceRules *arg1 = (FIX::NoTimeInForceRules *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoTimeInForceRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoTimeInForceRules, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoTimeInForceRules" "', argument " "1"" of type '" "FIX::NoTimeInForceRules *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoTimeInForceRules * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoRootPartySubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRootPartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoRootPartySubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRootPartySubIDs *)new FIX::NoRootPartySubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRootPartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRootPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoRootPartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRootPartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoRootPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRootPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRootPartySubIDs *)new FIX::NoRootPartySubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRootPartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRootPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoRootPartySubIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoRootPartySubIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoRootPartySubIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoRootPartySubIDs::NoRootPartySubIDs()\n"
    "    FIX::NoRootPartySubIDs::NoRootPartySubIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoRootPartySubIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRootPartySubIDs *arg1 = (FIX::NoRootPartySubIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoRootPartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoRootPartySubIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoRootPartySubIDs" "', argument " "1"" of type '" "FIX::NoRootPartySubIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoRootPartySubIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DisplayMinIncr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DisplayMinIncr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DisplayMinIncr")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DisplayMinIncr *)new FIX::DisplayMinIncr();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DisplayMinIncr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayMinIncr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DisplayMinIncr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DisplayMinIncr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DisplayMinIncr" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DisplayMinIncr" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DisplayMinIncr *)new FIX::DisplayMinIncr((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DisplayMinIncr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayMinIncr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DisplayMinIncr__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DisplayMinIncr__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DisplayMinIncr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DisplayMinIncr::DisplayMinIncr()\n"
    "    FIX::DisplayMinIncr::DisplayMinIncr(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DisplayMinIncr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DisplayMinIncr *arg1 = (FIX::DisplayMinIncr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DisplayMinIncr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DisplayMinIncr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DisplayMinIncr" "', argument " "1"" of type '" "FIX::DisplayMinIncr *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DisplayMinIncr * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TrdRegTimestampType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdRegTimestampType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TrdRegTimestampType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdRegTimestampType *)new FIX::TrdRegTimestampType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdRegTimestampType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestampType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TrdRegTimestampType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TrdRegTimestampType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrdRegTimestampType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TrdRegTimestampType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdRegTimestampType *)new FIX::TrdRegTimestampType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdRegTimestampType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestampType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TrdRegTimestampType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdRegTimestampType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TrdRegTimestampType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TrdRegTimestampType::TrdRegTimestampType()\n"
    "    FIX::TrdRegTimestampType::TrdRegTimestampType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TrdRegTimestampType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdRegTimestampType *arg1 = (FIX::TrdRegTimestampType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TrdRegTimestampType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TrdRegTimestampType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrdRegTimestampType" "', argument " "1"" of type '" "FIX::TrdRegTimestampType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TrdRegTimestampType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegProduct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegProduct *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegProduct")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegProduct *)new FIX::LegProduct();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegProduct, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegProduct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegProduct *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegProduct",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegProduct" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegProduct" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegProduct *)new FIX::LegProduct((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegProduct, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegProduct(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegProduct__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegProduct__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegProduct'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegProduct::LegProduct()\n"
    "    FIX::LegProduct::LegProduct(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegProduct *arg1 = (FIX::LegProduct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegProduct",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegProduct, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegProduct" "', argument " "1"" of type '" "FIX::LegProduct *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegProduct * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ApplVerID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplVerID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplVerID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplVerID *)new FIX::ApplVerID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplVerID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplVerID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplVerID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplVerID *)new FIX::ApplVerID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplVerID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplVerID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplVerID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplVerID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplVerID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplVerID::ApplVerID()\n"
    "    FIX::ApplVerID::ApplVerID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplVerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplVerID *arg1 = (FIX::ApplVerID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplVerID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplVerID" "', argument " "1"" of type '" "FIX::ApplVerID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplVerID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_HandlInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HandlInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HandlInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HandlInst *)new FIX::HandlInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HandlInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HandlInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::HandlInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HandlInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HandlInst" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HandlInst" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HandlInst *)new FIX::HandlInst((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HandlInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HandlInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_HandlInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HandlInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HandlInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::HandlInst::HandlInst()\n"
    "    FIX::HandlInst::HandlInst(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HandlInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HandlInst *arg1 = (FIX::HandlInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HandlInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__HandlInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HandlInst" "', argument " "1"" of type '" "FIX::HandlInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::HandlInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ListUpdateAction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListUpdateAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ListUpdateAction")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListUpdateAction *)new FIX::ListUpdateAction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListUpdateAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListUpdateAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ListUpdateAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ListUpdateAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListUpdateAction *)new FIX::ListUpdateAction((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListUpdateAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListUpdateAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ListUpdateAction__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListUpdateAction__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ListUpdateAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ListUpdateAction::ListUpdateAction()\n"
    "    FIX::ListUpdateAction::ListUpdateAction(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListUpdateAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListUpdateAction *arg1 = (FIX::ListUpdateAction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ListUpdateAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ListUpdateAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListUpdateAction" "', argument " "1"" of type '" "FIX::ListUpdateAction *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ListUpdateAction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NestedInstrAttribValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NestedInstrAttribValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NestedInstrAttribValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NestedInstrAttribValue *)new FIX::NestedInstrAttribValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NestedInstrAttribValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedInstrAttribValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NestedInstrAttribValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NestedInstrAttribValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NestedInstrAttribValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NestedInstrAttribValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NestedInstrAttribValue *)new FIX::NestedInstrAttribValue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NestedInstrAttribValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedInstrAttribValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NestedInstrAttribValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NestedInstrAttribValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NestedInstrAttribValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NestedInstrAttribValue::NestedInstrAttribValue()\n"
    "    FIX::NestedInstrAttribValue::NestedInstrAttribValue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NestedInstrAttribValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NestedInstrAttribValue *arg1 = (FIX::NestedInstrAttribValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NestedInstrAttribValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NestedInstrAttribValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NestedInstrAttribValue" "', argument " "1"" of type '" "FIX::NestedInstrAttribValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NestedInstrAttribValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradingSessionSubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradingSessionSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradingSessionSubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradingSessionSubID *)new FIX::TradingSessionSubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradingSessionSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingSessionSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradingSessionSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradingSessionSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradingSessionSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradingSessionSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradingSessionSubID *)new FIX::TradingSessionSubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradingSessionSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingSessionSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradingSessionSubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradingSessionSubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradingSessionSubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradingSessionSubID::TradingSessionSubID()\n"
    "    FIX::TradingSessionSubID::TradingSessionSubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradingSessionSubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradingSessionSubID *arg1 = (FIX::TradingSessionSubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradingSessionSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradingSessionSubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradingSessionSubID" "', argument " "1"" of type '" "FIX::TradingSessionSubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradingSessionSubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RFQReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RFQReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RFQReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RFQReqID *)new FIX::RFQReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RFQReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RFQReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RFQReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RFQReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RFQReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RFQReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RFQReqID *)new FIX::RFQReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RFQReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RFQReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RFQReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RFQReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RFQReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RFQReqID::RFQReqID()\n"
    "    FIX::RFQReqID::RFQReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RFQReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RFQReqID *arg1 = (FIX::RFQReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RFQReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RFQReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RFQReqID" "', argument " "1"" of type '" "FIX::RFQReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RFQReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingLegSymbolSfx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSymbolSfx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegSymbolSfx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSymbolSfx *)new FIX::UnderlyingLegSymbolSfx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSymbolSfx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSymbolSfx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegSymbolSfx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegSymbolSfx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSymbolSfx *)new FIX::UnderlyingLegSymbolSfx((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSymbolSfx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSymbolSfx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegSymbolSfx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSymbolSfx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegSymbolSfx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegSymbolSfx::UnderlyingLegSymbolSfx()\n"
    "    FIX::UnderlyingLegSymbolSfx::UnderlyingLegSymbolSfx(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegSymbolSfx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSymbolSfx *arg1 = (FIX::UnderlyingLegSymbolSfx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegSymbolSfx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegSymbolSfx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegSymbolSfx" "', argument " "1"" of type '" "FIX::UnderlyingLegSymbolSfx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegSymbolSfx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LiquidityNumSecurities__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LiquidityNumSecurities *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LiquidityNumSecurities")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LiquidityNumSecurities *)new FIX::LiquidityNumSecurities();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LiquidityNumSecurities, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityNumSecurities__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LiquidityNumSecurities *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LiquidityNumSecurities",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LiquidityNumSecurities" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LiquidityNumSecurities" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LiquidityNumSecurities *)new FIX::LiquidityNumSecurities((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LiquidityNumSecurities, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityNumSecurities(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LiquidityNumSecurities__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LiquidityNumSecurities__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LiquidityNumSecurities'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LiquidityNumSecurities::LiquidityNumSecurities()\n"
    "    FIX::LiquidityNumSecurities::LiquidityNumSecurities(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LiquidityNumSecurities(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LiquidityNumSecurities *arg1 = (FIX::LiquidityNumSecurities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LiquidityNumSecurities",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LiquidityNumSecurities, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LiquidityNumSecurities" "', argument " "1"" of type '" "FIX::LiquidityNumSecurities *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LiquidityNumSecurities * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoMsgTypes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMsgTypes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoMsgTypes")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMsgTypes *)new FIX::NoMsgTypes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMsgTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMsgTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoMsgTypes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoMsgTypes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoMsgTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoMsgTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMsgTypes *)new FIX::NoMsgTypes((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMsgTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMsgTypes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoMsgTypes__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMsgTypes__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoMsgTypes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoMsgTypes::NoMsgTypes()\n"
    "    FIX::NoMsgTypes::NoMsgTypes(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoMsgTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMsgTypes *arg1 = (FIX::NoMsgTypes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoMsgTypes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoMsgTypes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoMsgTypes" "', argument " "1"" of type '" "FIX::NoMsgTypes *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoMsgTypes * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradSesStartTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesStartTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradSesStartTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesStartTime *)new FIX::TradSesStartTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesStartTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStartTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesStartTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesStartTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TradSesStartTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesStartTime *)new FIX::TradSesStartTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesStartTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStartTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesStartTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesStartTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesStartTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesStartTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesStartTime *)new FIX::TradSesStartTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesStartTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStartTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::TradSesStartTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TradSesStartTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesStartTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesStartTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TradSesStartTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesStartTime *)new FIX::TradSesStartTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesStartTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesStartTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradSesStartTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesStartTime__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_TradSesStartTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TradSesStartTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradSesStartTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradSesStartTime::TradSesStartTime()\n"
    "    FIX::TradSesStartTime::TradSesStartTime(bool)\n"
    "    FIX::TradSesStartTime::TradSesStartTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::TradSesStartTime::TradSesStartTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradSesStartTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesStartTime *arg1 = (FIX::TradSesStartTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradSesStartTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradSesStartTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradSesStartTime" "', argument " "1"" of type '" "FIX::TradSesStartTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradSesStartTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDEntryType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDEntryType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryType *)new FIX::MDEntryType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDEntryType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDEntryType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDEntryType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDEntryType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryType *)new FIX::MDEntryType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDEntryType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDEntryType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDEntryType::MDEntryType()\n"
    "    FIX::MDEntryType::MDEntryType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryType *arg1 = (FIX::MDEntryType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDEntryType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDEntryType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDEntryType" "', argument " "1"" of type '" "FIX::MDEntryType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDEntryType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AgreementCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AgreementCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AgreementCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AgreementCurrency *)new FIX::AgreementCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AgreementCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AgreementCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AgreementCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AgreementCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AgreementCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AgreementCurrency *)new FIX::AgreementCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AgreementCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AgreementCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AgreementCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AgreementCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AgreementCurrency::AgreementCurrency()\n"
    "    FIX::AgreementCurrency::AgreementCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AgreementCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AgreementCurrency *arg1 = (FIX::AgreementCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AgreementCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AgreementCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AgreementCurrency" "', argument " "1"" of type '" "FIX::AgreementCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AgreementCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PegMoveType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegMoveType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PegMoveType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegMoveType *)new FIX::PegMoveType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegMoveType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegMoveType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PegMoveType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PegMoveType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PegMoveType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PegMoveType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegMoveType *)new FIX::PegMoveType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegMoveType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegMoveType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PegMoveType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegMoveType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PegMoveType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PegMoveType::PegMoveType()\n"
    "    FIX::PegMoveType::PegMoveType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PegMoveType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegMoveType *arg1 = (FIX::PegMoveType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PegMoveType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PegMoveType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PegMoveType" "', argument " "1"" of type '" "FIX::PegMoveType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PegMoveType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PegDifference__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegDifference *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PegDifference")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegDifference *)new FIX::PegDifference();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegDifference, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegDifference__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PegDifference *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PegDifference",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PegDifference" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PegDifference" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegDifference *)new FIX::PegDifference((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegDifference, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegDifference(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PegDifference__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegDifference__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PegDifference'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PegDifference::PegDifference()\n"
    "    FIX::PegDifference::PegDifference(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PegDifference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegDifference *arg1 = (FIX::PegDifference *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PegDifference",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PegDifference, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PegDifference" "', argument " "1"" of type '" "FIX::PegDifference *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PegDifference * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Spread__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Spread *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Spread")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Spread *)new FIX::Spread();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Spread, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Spread__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Spread *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Spread",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Spread" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Spread" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Spread *)new FIX::Spread((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Spread, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Spread(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Spread__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Spread__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Spread'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Spread::Spread()\n"
    "    FIX::Spread::Spread(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Spread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Spread *arg1 = (FIX::Spread *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Spread",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Spread, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Spread" "', argument " "1"" of type '" "FIX::Spread *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Spread * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedAllocTextLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedAllocTextLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedAllocTextLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedAllocTextLen *)new FIX::EncodedAllocTextLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedAllocTextLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedAllocTextLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedAllocTextLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedAllocTextLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedAllocTextLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedAllocTextLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedAllocTextLen *)new FIX::EncodedAllocTextLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedAllocTextLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedAllocTextLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedAllocTextLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedAllocTextLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedAllocTextLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedAllocTextLen::EncodedAllocTextLen()\n"
    "    FIX::EncodedAllocTextLen::EncodedAllocTextLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedAllocTextLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedAllocTextLen *arg1 = (FIX::EncodedAllocTextLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedAllocTextLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedAllocTextLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedAllocTextLen" "', argument " "1"" of type '" "FIX::EncodedAllocTextLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedAllocTextLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OutsideIndexPct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OutsideIndexPct *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OutsideIndexPct")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OutsideIndexPct *)new FIX::OutsideIndexPct();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OutsideIndexPct, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutsideIndexPct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OutsideIndexPct *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OutsideIndexPct",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OutsideIndexPct" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OutsideIndexPct" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OutsideIndexPct *)new FIX::OutsideIndexPct((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OutsideIndexPct, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutsideIndexPct(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OutsideIndexPct__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OutsideIndexPct__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OutsideIndexPct'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OutsideIndexPct::OutsideIndexPct()\n"
    "    FIX::OutsideIndexPct::OutsideIndexPct(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OutsideIndexPct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OutsideIndexPct *arg1 = (FIX::OutsideIndexPct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OutsideIndexPct",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OutsideIndexPct, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OutsideIndexPct" "', argument " "1"" of type '" "FIX::OutsideIndexPct *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OutsideIndexPct * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivFlexProductEligibilityIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivFlexProductEligibilityIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivFlexProductEligibilityIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivFlexProductEligibilityIndicator *)new FIX::DerivFlexProductEligibilityIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivFlexProductEligibilityIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivFlexProductEligibilityIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivFlexProductEligibilityIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivFlexProductEligibilityIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivFlexProductEligibilityIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivFlexProductEligibilityIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivFlexProductEligibilityIndicator *)new FIX::DerivFlexProductEligibilityIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivFlexProductEligibilityIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivFlexProductEligibilityIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivFlexProductEligibilityIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivFlexProductEligibilityIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivFlexProductEligibilityIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivFlexProductEligibilityIndicator::DerivFlexProductEligibilityIndicator()\n"
    "    FIX::DerivFlexProductEligibilityIndicator::DerivFlexProductEligibilityIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivFlexProductEligibilityIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivFlexProductEligibilityIndicator *arg1 = (FIX::DerivFlexProductEligibilityIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivFlexProductEligibilityIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivFlexProductEligibilityIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivFlexProductEligibilityIndicator" "', argument " "1"" of type '" "FIX::DerivFlexProductEligibilityIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivFlexProductEligibilityIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AvgPxIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AvgPxIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AvgPxIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AvgPxIndicator *)new FIX::AvgPxIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AvgPxIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPxIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AvgPxIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AvgPxIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AvgPxIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AvgPxIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AvgPxIndicator *)new FIX::AvgPxIndicator((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AvgPxIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPxIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AvgPxIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AvgPxIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AvgPxIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AvgPxIndicator::AvgPxIndicator()\n"
    "    FIX::AvgPxIndicator::AvgPxIndicator(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AvgPxIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AvgPxIndicator *arg1 = (FIX::AvgPxIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AvgPxIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AvgPxIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AvgPxIndicator" "', argument " "1"" of type '" "FIX::AvgPxIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AvgPxIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoIOIQualifiers__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoIOIQualifiers *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoIOIQualifiers")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoIOIQualifiers *)new FIX::NoIOIQualifiers();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoIOIQualifiers, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoIOIQualifiers__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoIOIQualifiers *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoIOIQualifiers",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoIOIQualifiers" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoIOIQualifiers" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoIOIQualifiers *)new FIX::NoIOIQualifiers((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoIOIQualifiers, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoIOIQualifiers(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoIOIQualifiers__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoIOIQualifiers__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoIOIQualifiers'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoIOIQualifiers::NoIOIQualifiers()\n"
    "    FIX::NoIOIQualifiers::NoIOIQualifiers(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoIOIQualifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoIOIQualifiers *arg1 = (FIX::NoIOIQualifiers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoIOIQualifiers",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoIOIQualifiers, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoIOIQualifiers" "', argument " "1"" of type '" "FIX::NoIOIQualifiers *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoIOIQualifiers * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CancellationRights__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CancellationRights *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CancellationRights")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CancellationRights *)new FIX::CancellationRights();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CancellationRights, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CancellationRights__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CancellationRights *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CancellationRights",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CancellationRights" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CancellationRights" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CancellationRights *)new FIX::CancellationRights((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CancellationRights, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CancellationRights(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CancellationRights__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CancellationRights__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CancellationRights'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CancellationRights::CancellationRights()\n"
    "    FIX::CancellationRights::CancellationRights(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CancellationRights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CancellationRights *arg1 = (FIX::CancellationRights *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CancellationRights",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CancellationRights, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CancellationRights" "', argument " "1"" of type '" "FIX::CancellationRights *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CancellationRights * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ListSeqNo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListSeqNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ListSeqNo")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListSeqNo *)new FIX::ListSeqNo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListSeqNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListSeqNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ListSeqNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ListSeqNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListSeqNo" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListSeqNo" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListSeqNo *)new FIX::ListSeqNo((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListSeqNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListSeqNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ListSeqNo__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListSeqNo__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ListSeqNo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ListSeqNo::ListSeqNo()\n"
    "    FIX::ListSeqNo::ListSeqNo(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListSeqNo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListSeqNo *arg1 = (FIX::ListSeqNo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ListSeqNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ListSeqNo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListSeqNo" "', argument " "1"" of type '" "FIX::ListSeqNo *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ListSeqNo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CardIssNum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CardIssNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CardIssNum")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CardIssNum *)new FIX::CardIssNum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CardIssNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardIssNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CardIssNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CardIssNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CardIssNum" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CardIssNum" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CardIssNum *)new FIX::CardIssNum((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CardIssNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardIssNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CardIssNum__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CardIssNum__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CardIssNum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CardIssNum::CardIssNum()\n"
    "    FIX::CardIssNum::CardIssNum(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CardIssNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CardIssNum *arg1 = (FIX::CardIssNum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CardIssNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CardIssNum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CardIssNum" "', argument " "1"" of type '" "FIX::CardIssNum *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CardIssNum * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedMktSegmDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedMktSegmDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedMktSegmDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedMktSegmDesc *)new FIX::EncodedMktSegmDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedMktSegmDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedMktSegmDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedMktSegmDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedMktSegmDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedMktSegmDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedMktSegmDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedMktSegmDesc *)new FIX::EncodedMktSegmDesc((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedMktSegmDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedMktSegmDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedMktSegmDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedMktSegmDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedMktSegmDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedMktSegmDesc::EncodedMktSegmDesc()\n"
    "    FIX::EncodedMktSegmDesc::EncodedMktSegmDesc(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedMktSegmDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedMktSegmDesc *arg1 = (FIX::EncodedMktSegmDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedMktSegmDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedMktSegmDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedMktSegmDesc" "', argument " "1"" of type '" "FIX::EncodedMktSegmDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedMktSegmDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeEventType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEventType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeEventType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEventType *)new FIX::DerivativeEventType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEventType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeEventType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeEventType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeEventType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeEventType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEventType *)new FIX::DerivativeEventType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEventType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeEventType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEventType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeEventType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeEventType::DerivativeEventType()\n"
    "    FIX::DerivativeEventType::DerivativeEventType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEventType *arg1 = (FIX::DerivativeEventType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeEventType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeEventType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeEventType" "', argument " "1"" of type '" "FIX::DerivativeEventType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeEventType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeMaturityMonthYear__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeMaturityMonthYear *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeMaturityMonthYear")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeMaturityMonthYear *)new FIX::DerivativeMaturityMonthYear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeMaturityMonthYear *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeMaturityMonthYear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeMaturityMonthYear *)new FIX::DerivativeMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeMaturityMonthYear__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeMaturityMonthYear__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeMaturityMonthYear'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeMaturityMonthYear::DerivativeMaturityMonthYear()\n"
    "    FIX::DerivativeMaturityMonthYear::DerivativeMaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeMaturityMonthYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeMaturityMonthYear *arg1 = (FIX::DerivativeMaturityMonthYear *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeMaturityMonthYear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeMaturityMonthYear, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeMaturityMonthYear" "', argument " "1"" of type '" "FIX::DerivativeMaturityMonthYear *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeMaturityMonthYear * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SideTradeReportID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideTradeReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideTradeReportID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTradeReportID *)new FIX::SideTradeReportID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTradeReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTradeReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideTradeReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideTradeReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideTradeReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideTradeReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTradeReportID *)new FIX::SideTradeReportID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTradeReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTradeReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideTradeReportID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideTradeReportID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideTradeReportID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideTradeReportID::SideTradeReportID()\n"
    "    FIX::SideTradeReportID::SideTradeReportID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideTradeReportID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideTradeReportID *arg1 = (FIX::SideTradeReportID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideTradeReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideTradeReportID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideTradeReportID" "', argument " "1"" of type '" "FIX::SideTradeReportID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideTradeReportID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoQuoteSets__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoQuoteSets *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoQuoteSets")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoQuoteSets *)new FIX::NoQuoteSets();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoQuoteSets, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoQuoteSets__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoQuoteSets *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoQuoteSets",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoQuoteSets" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoQuoteSets" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoQuoteSets *)new FIX::NoQuoteSets((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoQuoteSets, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoQuoteSets(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoQuoteSets__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoQuoteSets__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoQuoteSets'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoQuoteSets::NoQuoteSets()\n"
    "    FIX::NoQuoteSets::NoQuoteSets(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoQuoteSets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoQuoteSets *arg1 = (FIX::NoQuoteSets *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoQuoteSets",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoQuoteSets, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoQuoteSets" "', argument " "1"" of type '" "FIX::NoQuoteSets *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoQuoteSets * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Nested4PartySubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested4PartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested4PartySubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested4PartySubIDType *)new FIX::Nested4PartySubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested4PartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested4PartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested4PartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested4PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested4PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested4PartySubIDType *)new FIX::Nested4PartySubIDType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested4PartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested4PartySubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested4PartySubIDType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested4PartySubIDType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested4PartySubIDType::Nested4PartySubIDType()\n"
    "    FIX::Nested4PartySubIDType::Nested4PartySubIDType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested4PartySubIDType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested4PartySubIDType *arg1 = (FIX::Nested4PartySubIDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested4PartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested4PartySubIDType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested4PartySubIDType" "', argument " "1"" of type '" "FIX::Nested4PartySubIDType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested4PartySubIDType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FillPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FillPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FillPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FillPx *)new FIX::FillPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FillPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FillPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FillPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FillPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FillPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FillPx *)new FIX::FillPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FillPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FillPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FillPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FillPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FillPx::FillPx()\n"
    "    FIX::FillPx::FillPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FillPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FillPx *arg1 = (FIX::FillPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FillPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FillPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FillPx" "', argument " "1"" of type '" "FIX::FillPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FillPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StrikeExerciseStyle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikeExerciseStyle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StrikeExerciseStyle")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeExerciseStyle *)new FIX::StrikeExerciseStyle();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeExerciseStyle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeExerciseStyle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrikeExerciseStyle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrikeExerciseStyle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrikeExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrikeExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeExerciseStyle *)new FIX::StrikeExerciseStyle((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeExerciseStyle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeExerciseStyle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StrikeExerciseStyle__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikeExerciseStyle__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StrikeExerciseStyle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StrikeExerciseStyle::StrikeExerciseStyle()\n"
    "    FIX::StrikeExerciseStyle::StrikeExerciseStyle(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StrikeExerciseStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikeExerciseStyle *arg1 = (FIX::StrikeExerciseStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrikeExerciseStyle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StrikeExerciseStyle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrikeExerciseStyle" "', argument " "1"" of type '" "FIX::StrikeExerciseStyle *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StrikeExerciseStyle * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DeskID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeskID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DeskID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeskID *)new FIX::DeskID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeskID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DeskID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DeskID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeskID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeskID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeskID *)new FIX::DeskID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeskID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DeskID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeskID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DeskID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DeskID::DeskID()\n"
    "    FIX::DeskID::DeskID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DeskID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeskID *arg1 = (FIX::DeskID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DeskID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DeskID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeskID" "', argument " "1"" of type '" "FIX::DeskID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DeskID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CrossPercent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CrossPercent *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CrossPercent")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CrossPercent *)new FIX::CrossPercent();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CrossPercent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossPercent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CrossPercent *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CrossPercent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CrossPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CrossPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CrossPercent *)new FIX::CrossPercent((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CrossPercent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossPercent(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CrossPercent__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CrossPercent__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CrossPercent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CrossPercent::CrossPercent()\n"
    "    FIX::CrossPercent::CrossPercent(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CrossPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CrossPercent *arg1 = (FIX::CrossPercent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CrossPercent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CrossPercent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CrossPercent" "', argument " "1"" of type '" "FIX::CrossPercent *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CrossPercent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MaturityMonthYear__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityMonthYear *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaturityMonthYear")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityMonthYear *)new FIX::MaturityMonthYear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityMonthYear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaturityMonthYear *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaturityMonthYear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityMonthYear *)new FIX::MaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityMonthYear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaturityMonthYear__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityMonthYear__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaturityMonthYear'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaturityMonthYear::MaturityMonthYear()\n"
    "    FIX::MaturityMonthYear::MaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaturityMonthYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityMonthYear *arg1 = (FIX::MaturityMonthYear *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaturityMonthYear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaturityMonthYear, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaturityMonthYear" "', argument " "1"" of type '" "FIX::MaturityMonthYear *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaturityMonthYear * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ComplexEventPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ComplexEventPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventPrice *)new FIX::ComplexEventPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ComplexEventPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ComplexEventPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexEventPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplexEventPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventPrice *)new FIX::ComplexEventPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ComplexEventPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ComplexEventPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ComplexEventPrice::ComplexEventPrice()\n"
    "    FIX::ComplexEventPrice::ComplexEventPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ComplexEventPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventPrice *arg1 = (FIX::ComplexEventPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ComplexEventPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ComplexEventPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComplexEventPrice" "', argument " "1"" of type '" "FIX::ComplexEventPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ComplexEventPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoNewsRefIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNewsRefIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoNewsRefIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNewsRefIDs *)new FIX::NoNewsRefIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNewsRefIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNewsRefIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoNewsRefIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoNewsRefIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoNewsRefIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoNewsRefIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNewsRefIDs *)new FIX::NoNewsRefIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNewsRefIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNewsRefIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoNewsRefIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNewsRefIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoNewsRefIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoNewsRefIDs::NoNewsRefIDs()\n"
    "    FIX::NoNewsRefIDs::NoNewsRefIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoNewsRefIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNewsRefIDs *arg1 = (FIX::NoNewsRefIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoNewsRefIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoNewsRefIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoNewsRefIDs" "', argument " "1"" of type '" "FIX::NoNewsRefIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoNewsRefIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingCapValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCapValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingCapValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCapValue *)new FIX::UnderlyingCapValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCapValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCapValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingCapValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingCapValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingCapValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingCapValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCapValue *)new FIX::UnderlyingCapValue((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCapValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCapValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingCapValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCapValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingCapValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingCapValue::UnderlyingCapValue()\n"
    "    FIX::UnderlyingCapValue::UnderlyingCapValue(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingCapValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCapValue *arg1 = (FIX::UnderlyingCapValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingCapValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingCapValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingCapValue" "', argument " "1"" of type '" "FIX::UnderlyingCapValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingCapValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CPRegType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CPRegType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CPRegType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CPRegType *)new FIX::CPRegType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CPRegType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPRegType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CPRegType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CPRegType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CPRegType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPRegType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CPRegType *)new FIX::CPRegType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CPRegType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPRegType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CPRegType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CPRegType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CPRegType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CPRegType::CPRegType()\n"
    "    FIX::CPRegType::CPRegType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CPRegType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CPRegType *arg1 = (FIX::CPRegType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CPRegType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CPRegType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPRegType" "', argument " "1"" of type '" "FIX::CPRegType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CPRegType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CashDistribAgentCode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashDistribAgentCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashDistribAgentCode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashDistribAgentCode *)new FIX::CashDistribAgentCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashDistribAgentCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashDistribAgentCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashDistribAgentCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashDistribAgentCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashDistribAgentCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashDistribAgentCode *)new FIX::CashDistribAgentCode((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashDistribAgentCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashDistribAgentCode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashDistribAgentCode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashDistribAgentCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashDistribAgentCode::CashDistribAgentCode()\n"
    "    FIX::CashDistribAgentCode::CashDistribAgentCode(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashDistribAgentCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashDistribAgentCode *arg1 = (FIX::CashDistribAgentCode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashDistribAgentCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashDistribAgentCode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashDistribAgentCode" "', argument " "1"" of type '" "FIX::CashDistribAgentCode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashDistribAgentCode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ExecPriceType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExecPriceType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecPriceType *)new FIX::ExecPriceType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExecPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExecPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExecPriceType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExecPriceType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecPriceType *)new FIX::ExecPriceType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExecPriceType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecPriceType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExecPriceType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExecPriceType::ExecPriceType()\n"
    "    FIX::ExecPriceType::ExecPriceType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExecPriceType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecPriceType *arg1 = (FIX::ExecPriceType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExecPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExecPriceType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExecPriceType" "', argument " "1"" of type '" "FIX::ExecPriceType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExecPriceType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegAllocID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegAllocID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegAllocID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegAllocID *)new FIX::LegAllocID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegAllocID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegAllocID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegAllocID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegAllocID *)new FIX::LegAllocID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegAllocID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegAllocID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegAllocID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegAllocID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegAllocID::LegAllocID()\n"
    "    FIX::LegAllocID::LegAllocID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegAllocID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegAllocID *arg1 = (FIX::LegAllocID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegAllocID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegAllocID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegAllocID" "', argument " "1"" of type '" "FIX::LegAllocID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegAllocID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDEntryTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDEntryTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryTime *)new FIX::MDEntryTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMEONLY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDEntryTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDEntryTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMEONLY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDEntryTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDEntryTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMEONLY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryTime *)new FIX::MDEntryTime((FIX::UTCTIMEONLY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDEntryTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryTime__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDEntryTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDEntryTime::MDEntryTime()\n"
    "    FIX::MDEntryTime::MDEntryTime(FIX::UTCTIMEONLY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDEntryTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryTime *arg1 = (FIX::MDEntryTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDEntryTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDEntryTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDEntryTime" "', argument " "1"" of type '" "FIX::MDEntryTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDEntryTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TotalNumSecurities__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalNumSecurities *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotalNumSecurities")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalNumSecurities *)new FIX::TotalNumSecurities();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalNumSecurities, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNumSecurities__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotalNumSecurities *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotalNumSecurities",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotalNumSecurities" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotalNumSecurities" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalNumSecurities *)new FIX::TotalNumSecurities((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalNumSecurities, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNumSecurities(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotalNumSecurities__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalNumSecurities__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotalNumSecurities'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotalNumSecurities::TotalNumSecurities()\n"
    "    FIX::TotalNumSecurities::TotalNumSecurities(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotalNumSecurities(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalNumSecurities *arg1 = (FIX::TotalNumSecurities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotalNumSecurities",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotalNumSecurities, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotalNumSecurities" "', argument " "1"" of type '" "FIX::TotalNumSecurities *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotalNumSecurities * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AllocSettlInstType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocSettlInstType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocSettlInstType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocSettlInstType *)new FIX::AllocSettlInstType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocSettlInstType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocSettlInstType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocSettlInstType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocSettlInstType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocSettlInstType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocSettlInstType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocSettlInstType *)new FIX::AllocSettlInstType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocSettlInstType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocSettlInstType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocSettlInstType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocSettlInstType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocSettlInstType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocSettlInstType::AllocSettlInstType()\n"
    "    FIX::AllocSettlInstType::AllocSettlInstType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocSettlInstType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocSettlInstType *arg1 = (FIX::AllocSettlInstType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocSettlInstType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocSettlInstType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocSettlInstType" "', argument " "1"" of type '" "FIX::AllocSettlInstType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocSettlInstType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TargetPartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TargetPartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetPartyID *)new FIX::TargetPartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TargetPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TargetPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TargetPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TargetPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetPartyID *)new FIX::TargetPartyID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TargetPartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetPartyID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TargetPartyID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TargetPartyID::TargetPartyID()\n"
    "    FIX::TargetPartyID::TargetPartyID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TargetPartyID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetPartyID *arg1 = (FIX::TargetPartyID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TargetPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TargetPartyID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TargetPartyID" "', argument " "1"" of type '" "FIX::TargetPartyID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TargetPartyID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeStrikeCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeStrikeCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeStrikeCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeStrikeCurrency *)new FIX::DerivativeStrikeCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeStrikeCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikeCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeStrikeCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeStrikeCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeStrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeStrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeStrikeCurrency *)new FIX::DerivativeStrikeCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeStrikeCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikeCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeStrikeCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeStrikeCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeStrikeCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeStrikeCurrency::DerivativeStrikeCurrency()\n"
    "    FIX::DerivativeStrikeCurrency::DerivativeStrikeCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeStrikeCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeStrikeCurrency *arg1 = (FIX::DerivativeStrikeCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeStrikeCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeStrikeCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeStrikeCurrency" "', argument " "1"" of type '" "FIX::DerivativeStrikeCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeStrikeCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StatsType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StatsType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StatsType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StatsType *)new FIX::StatsType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StatsType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StatsType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StatsType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StatsType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StatsType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StatsType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StatsType *)new FIX::StatsType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StatsType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StatsType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StatsType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StatsType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StatsType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StatsType::StatsType()\n"
    "    FIX::StatsType::StatsType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StatsType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StatsType *arg1 = (FIX::StatsType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StatsType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StatsType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StatsType" "', argument " "1"" of type '" "FIX::StatsType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StatsType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ApplExtID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplExtID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplExtID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplExtID *)new FIX::ApplExtID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplExtID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplExtID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplExtID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplExtID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplExtID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplExtID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplExtID *)new FIX::ApplExtID((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplExtID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplExtID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplExtID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplExtID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplExtID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplExtID::ApplExtID()\n"
    "    FIX::ApplExtID::ApplExtID(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplExtID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplExtID *arg1 = (FIX::ApplExtID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplExtID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplExtID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplExtID" "', argument " "1"" of type '" "FIX::ApplExtID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplExtID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlementCycleNo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlementCycleNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlementCycleNo")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlementCycleNo *)new FIX::SettlementCycleNo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlementCycleNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlementCycleNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlementCycleNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlementCycleNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlementCycleNo" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlementCycleNo" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlementCycleNo *)new FIX::SettlementCycleNo((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlementCycleNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlementCycleNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlementCycleNo__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlementCycleNo__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlementCycleNo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlementCycleNo::SettlementCycleNo()\n"
    "    FIX::SettlementCycleNo::SettlementCycleNo(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlementCycleNo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlementCycleNo *arg1 = (FIX::SettlementCycleNo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlementCycleNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlementCycleNo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlementCycleNo" "', argument " "1"" of type '" "FIX::SettlementCycleNo *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlementCycleNo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingStrikeCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingStrikeCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingStrikeCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingStrikeCurrency *)new FIX::UnderlyingStrikeCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingStrikeCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStrikeCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingStrikeCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingStrikeCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingStrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingStrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingStrikeCurrency *)new FIX::UnderlyingStrikeCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingStrikeCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStrikeCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingStrikeCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingStrikeCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingStrikeCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingStrikeCurrency::UnderlyingStrikeCurrency()\n"
    "    FIX::UnderlyingStrikeCurrency::UnderlyingStrikeCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingStrikeCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingStrikeCurrency *arg1 = (FIX::UnderlyingStrikeCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingStrikeCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingStrikeCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingStrikeCurrency" "', argument " "1"" of type '" "FIX::UnderlyingStrikeCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingStrikeCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradSesMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesMode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradSesMode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesMode *)new FIX::TradSesMode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesMode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesMode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesMode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesMode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesMode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesMode *)new FIX::TradSesMode((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesMode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesMode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradSesMode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesMode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradSesMode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradSesMode::TradSesMode()\n"
    "    FIX::TradSesMode::TradSesMode(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradSesMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesMode *arg1 = (FIX::TradSesMode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradSesMode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradSesMode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradSesMode" "', argument " "1"" of type '" "FIX::TradSesMode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradSesMode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlInstSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlInstSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstSource *)new FIX::SettlInstSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlInstSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlInstSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlInstSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlInstSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstSource *)new FIX::SettlInstSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlInstSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlInstSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlInstSource::SettlInstSource()\n"
    "    FIX::SettlInstSource::SettlInstSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlInstSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstSource *arg1 = (FIX::SettlInstSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlInstSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlInstSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlInstSource" "', argument " "1"" of type '" "FIX::SettlInstSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlInstSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegSecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecurityDesc *)new FIX::UnderlyingLegSecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecurityDesc *)new FIX::UnderlyingLegSecurityDesc((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegSecurityDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecurityDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegSecurityDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegSecurityDesc::UnderlyingLegSecurityDesc()\n"
    "    FIX::UnderlyingLegSecurityDesc::UnderlyingLegSecurityDesc(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegSecurityDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecurityDesc *arg1 = (FIX::UnderlyingLegSecurityDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegSecurityDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegSecurityDesc" "', argument " "1"" of type '" "FIX::UnderlyingLegSecurityDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegSecurityDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrumentParties__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDerivativeInstrumentParties *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoDerivativeInstrumentParties")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDerivativeInstrumentParties *)new FIX::NoDerivativeInstrumentParties();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDerivativeInstrumentParties, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrumentParties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoDerivativeInstrumentParties *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoDerivativeInstrumentParties",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoDerivativeInstrumentParties" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoDerivativeInstrumentParties" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDerivativeInstrumentParties *)new FIX::NoDerivativeInstrumentParties((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDerivativeInstrumentParties, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrumentParties(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoDerivativeInstrumentParties__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDerivativeInstrumentParties__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoDerivativeInstrumentParties'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoDerivativeInstrumentParties::NoDerivativeInstrumentParties()\n"
    "    FIX::NoDerivativeInstrumentParties::NoDerivativeInstrumentParties(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoDerivativeInstrumentParties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDerivativeInstrumentParties *arg1 = (FIX::NoDerivativeInstrumentParties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoDerivativeInstrumentParties",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoDerivativeInstrumentParties, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoDerivativeInstrumentParties" "', argument " "1"" of type '" "FIX::NoDerivativeInstrumentParties *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoDerivativeInstrumentParties * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeEventTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEventTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeEventTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEventTime *)new FIX::DerivativeEventTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEventTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeEventTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeEventTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DerivativeEventTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEventTime *)new FIX::DerivativeEventTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEventTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeEventTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeEventTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeEventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeEventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEventTime *)new FIX::DerivativeEventTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEventTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::DerivativeEventTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_DerivativeEventTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeEventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeEventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DerivativeEventTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEventTime *)new FIX::DerivativeEventTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEventTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeEventTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEventTime__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_DerivativeEventTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DerivativeEventTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeEventTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeEventTime::DerivativeEventTime()\n"
    "    FIX::DerivativeEventTime::DerivativeEventTime(bool)\n"
    "    FIX::DerivativeEventTime::DerivativeEventTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::DerivativeEventTime::DerivativeEventTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeEventTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEventTime *arg1 = (FIX::DerivativeEventTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeEventTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeEventTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeEventTime" "', argument " "1"" of type '" "FIX::DerivativeEventTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeEventTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TickIncrement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TickIncrement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TickIncrement")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TickIncrement *)new FIX::TickIncrement();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TickIncrement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TickIncrement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TickIncrement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TickIncrement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TickIncrement" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TickIncrement" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TickIncrement *)new FIX::TickIncrement((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TickIncrement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TickIncrement(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TickIncrement__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TickIncrement__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TickIncrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TickIncrement::TickIncrement()\n"
    "    FIX::TickIncrement::TickIncrement(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TickIncrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TickIncrement *arg1 = (FIX::TickIncrement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TickIncrement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TickIncrement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TickIncrement" "', argument " "1"" of type '" "FIX::TickIncrement *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TickIncrement * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UndlyInstrumentPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UndlyInstrumentPartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UndlyInstrumentPartyID *)new FIX::UndlyInstrumentPartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UndlyInstrumentPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UndlyInstrumentPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UndlyInstrumentPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UndlyInstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UndlyInstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UndlyInstrumentPartyID *)new FIX::UndlyInstrumentPartyID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UndlyInstrumentPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UndlyInstrumentPartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UndlyInstrumentPartyID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UndlyInstrumentPartyID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UndlyInstrumentPartyID::UndlyInstrumentPartyID()\n"
    "    FIX::UndlyInstrumentPartyID::UndlyInstrumentPartyID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UndlyInstrumentPartyID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UndlyInstrumentPartyID *arg1 = (FIX::UndlyInstrumentPartyID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UndlyInstrumentPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UndlyInstrumentPartyID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UndlyInstrumentPartyID" "', argument " "1"" of type '" "FIX::UndlyInstrumentPartyID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UndlyInstrumentPartyID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoUndlyInstrumentParties__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoUndlyInstrumentParties *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoUndlyInstrumentParties")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoUndlyInstrumentParties *)new FIX::NoUndlyInstrumentParties();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoUndlyInstrumentParties, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUndlyInstrumentParties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoUndlyInstrumentParties *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoUndlyInstrumentParties",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoUndlyInstrumentParties" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoUndlyInstrumentParties" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoUndlyInstrumentParties *)new FIX::NoUndlyInstrumentParties((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoUndlyInstrumentParties, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUndlyInstrumentParties(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoUndlyInstrumentParties__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoUndlyInstrumentParties__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoUndlyInstrumentParties'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoUndlyInstrumentParties::NoUndlyInstrumentParties()\n"
    "    FIX::NoUndlyInstrumentParties::NoUndlyInstrumentParties(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoUndlyInstrumentParties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoUndlyInstrumentParties *arg1 = (FIX::NoUndlyInstrumentParties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoUndlyInstrumentParties",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoUndlyInstrumentParties, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoUndlyInstrumentParties" "', argument " "1"" of type '" "FIX::NoUndlyInstrumentParties *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoUndlyInstrumentParties * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ExpType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExpType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExpType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExpType *)new FIX::ExpType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExpType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExpType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExpType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExpType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExpType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExpType *)new FIX::ExpType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExpType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExpType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExpType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExpType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExpType::ExpType()\n"
    "    FIX::ExpType::ExpType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExpType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExpType *arg1 = (FIX::ExpType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExpType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExpType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExpType" "', argument " "1"" of type '" "FIX::ExpType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExpType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecondaryClOrdID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryClOrdID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryClOrdID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryClOrdID *)new FIX::SecondaryClOrdID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryClOrdID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryClOrdID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryClOrdID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryClOrdID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryClOrdID *)new FIX::SecondaryClOrdID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryClOrdID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryClOrdID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryClOrdID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryClOrdID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryClOrdID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryClOrdID::SecondaryClOrdID()\n"
    "    FIX::SecondaryClOrdID::SecondaryClOrdID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryClOrdID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryClOrdID *arg1 = (FIX::SecondaryClOrdID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryClOrdID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryClOrdID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryClOrdID" "', argument " "1"" of type '" "FIX::SecondaryClOrdID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryClOrdID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlInstTransType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlInstTransType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstTransType *)new FIX::SettlInstTransType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlInstTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlInstTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlInstTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlInstTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstTransType *)new FIX::SettlInstTransType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlInstTransType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstTransType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlInstTransType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlInstTransType::SettlInstTransType()\n"
    "    FIX::SettlInstTransType::SettlInstTransType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlInstTransType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstTransType *arg1 = (FIX::SettlInstTransType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlInstTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlInstTransType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlInstTransType" "', argument " "1"" of type '" "FIX::SettlInstTransType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlInstTransType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SideComplianceID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideComplianceID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideComplianceID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideComplianceID *)new FIX::SideComplianceID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideComplianceID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideComplianceID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideComplianceID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideComplianceID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideComplianceID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideComplianceID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideComplianceID *)new FIX::SideComplianceID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideComplianceID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideComplianceID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideComplianceID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideComplianceID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideComplianceID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideComplianceID::SideComplianceID()\n"
    "    FIX::SideComplianceID::SideComplianceID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideComplianceID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideComplianceID *arg1 = (FIX::SideComplianceID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideComplianceID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideComplianceID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideComplianceID" "', argument " "1"" of type '" "FIX::SideComplianceID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideComplianceID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradeRequestResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeRequestResult *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeRequestResult")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeRequestResult *)new FIX::TradeRequestResult();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeRequestResult, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeRequestResult *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeRequestResult",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeRequestResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeRequestResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeRequestResult *)new FIX::TradeRequestResult((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeRequestResult, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestResult(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeRequestResult__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeRequestResult__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeRequestResult'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeRequestResult::TradeRequestResult()\n"
    "    FIX::TradeRequestResult::TradeRequestResult(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeRequestResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeRequestResult *arg1 = (FIX::TradeRequestResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeRequestResult",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeRequestResult, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeRequestResult" "', argument " "1"" of type '" "FIX::TradeRequestResult *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeRequestResult * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrigPosReqRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigPosReqRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrigPosReqRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigPosReqRefID *)new FIX::OrigPosReqRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigPosReqRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigPosReqRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrigPosReqRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrigPosReqRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrigPosReqRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrigPosReqRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigPosReqRefID *)new FIX::OrigPosReqRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigPosReqRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigPosReqRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrigPosReqRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigPosReqRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrigPosReqRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrigPosReqRefID::OrigPosReqRefID()\n"
    "    FIX::OrigPosReqRefID::OrigPosReqRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrigPosReqRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigPosReqRefID *arg1 = (FIX::OrigPosReqRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrigPosReqRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrigPosReqRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrigPosReqRefID" "', argument " "1"" of type '" "FIX::OrigPosReqRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrigPosReqRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrigCrossID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigCrossID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrigCrossID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigCrossID *)new FIX::OrigCrossID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigCrossID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigCrossID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrigCrossID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrigCrossID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrigCrossID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrigCrossID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigCrossID *)new FIX::OrigCrossID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigCrossID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigCrossID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrigCrossID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigCrossID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrigCrossID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrigCrossID::OrigCrossID()\n"
    "    FIX::OrigCrossID::OrigCrossID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrigCrossID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigCrossID *arg1 = (FIX::OrigCrossID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrigCrossID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrigCrossID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrigCrossID" "', argument " "1"" of type '" "FIX::OrigCrossID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrigCrossID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradeInputSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeInputSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeInputSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeInputSource *)new FIX::TradeInputSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeInputSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeInputSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeInputSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeInputSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeInputSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeInputSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeInputSource *)new FIX::TradeInputSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeInputSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeInputSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeInputSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeInputSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeInputSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeInputSource::TradeInputSource()\n"
    "    FIX::TradeInputSource::TradeInputSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeInputSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeInputSource *arg1 = (FIX::TradeInputSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeInputSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeInputSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeInputSource" "', argument " "1"" of type '" "FIX::TradeInputSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeInputSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrderQty2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderQty2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrderQty2")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderQty2 *)new FIX::OrderQty2();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderQty2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderQty2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrderQty2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrderQty2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrderQty2" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrderQty2" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderQty2 *)new FIX::OrderQty2((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderQty2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderQty2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrderQty2__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderQty2__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrderQty2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrderQty2::OrderQty2()\n"
    "    FIX::OrderQty2::OrderQty2(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrderQty2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderQty2 *arg1 = (FIX::OrderQty2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrderQty2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrderQty2, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrderQty2" "', argument " "1"" of type '" "FIX::OrderQty2 *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrderQty2 * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TestMessageIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TestMessageIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TestMessageIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TestMessageIndicator *)new FIX::TestMessageIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TestMessageIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TestMessageIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TestMessageIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TestMessageIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TestMessageIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TestMessageIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TestMessageIndicator *)new FIX::TestMessageIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TestMessageIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TestMessageIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TestMessageIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TestMessageIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TestMessageIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TestMessageIndicator::TestMessageIndicator()\n"
    "    FIX::TestMessageIndicator::TestMessageIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TestMessageIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TestMessageIndicator *arg1 = (FIX::TestMessageIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TestMessageIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TestMessageIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TestMessageIndicator" "', argument " "1"" of type '" "FIX::TestMessageIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TestMessageIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeEventDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEventDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeEventDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEventDate *)new FIX::DerivativeEventDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEventDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeEventDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeEventDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeEventDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeEventDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEventDate *)new FIX::DerivativeEventDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEventDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeEventDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEventDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeEventDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeEventDate::DerivativeEventDate()\n"
    "    FIX::DerivativeEventDate::DerivativeEventDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeEventDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEventDate *arg1 = (FIX::DerivativeEventDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeEventDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeEventDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeEventDate" "', argument " "1"" of type '" "FIX::DerivativeEventDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeEventDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SideGrossTradeAmt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideGrossTradeAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideGrossTradeAmt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideGrossTradeAmt *)new FIX::SideGrossTradeAmt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideGrossTradeAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideGrossTradeAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideGrossTradeAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideGrossTradeAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideGrossTradeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideGrossTradeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideGrossTradeAmt *)new FIX::SideGrossTradeAmt((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideGrossTradeAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideGrossTradeAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideGrossTradeAmt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideGrossTradeAmt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideGrossTradeAmt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideGrossTradeAmt::SideGrossTradeAmt()\n"
    "    FIX::SideGrossTradeAmt::SideGrossTradeAmt(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideGrossTradeAmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideGrossTradeAmt *arg1 = (FIX::SideGrossTradeAmt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideGrossTradeAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideGrossTradeAmt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideGrossTradeAmt" "', argument " "1"" of type '" "FIX::SideGrossTradeAmt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideGrossTradeAmt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PeggedPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PeggedPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PeggedPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PeggedPrice *)new FIX::PeggedPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PeggedPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PeggedPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PeggedPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PeggedPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PeggedPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PeggedPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PeggedPrice *)new FIX::PeggedPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PeggedPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PeggedPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PeggedPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PeggedPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PeggedPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PeggedPrice::PeggedPrice()\n"
    "    FIX::PeggedPrice::PeggedPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PeggedPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PeggedPrice *arg1 = (FIX::PeggedPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PeggedPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PeggedPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PeggedPrice" "', argument " "1"" of type '" "FIX::PeggedPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PeggedPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ExpirationCycle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExpirationCycle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExpirationCycle")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExpirationCycle *)new FIX::ExpirationCycle();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExpirationCycle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpirationCycle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExpirationCycle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExpirationCycle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExpirationCycle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExpirationCycle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExpirationCycle *)new FIX::ExpirationCycle((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExpirationCycle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpirationCycle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExpirationCycle__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExpirationCycle__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExpirationCycle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExpirationCycle::ExpirationCycle()\n"
    "    FIX::ExpirationCycle::ExpirationCycle(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExpirationCycle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExpirationCycle *arg1 = (FIX::ExpirationCycle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExpirationCycle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExpirationCycle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExpirationCycle" "', argument " "1"" of type '" "FIX::ExpirationCycle *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExpirationCycle * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AllocCancReplaceReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocCancReplaceReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocCancReplaceReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocCancReplaceReason *)new FIX::AllocCancReplaceReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocCancReplaceReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocCancReplaceReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocCancReplaceReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocCancReplaceReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocCancReplaceReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocCancReplaceReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocCancReplaceReason *)new FIX::AllocCancReplaceReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocCancReplaceReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocCancReplaceReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocCancReplaceReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocCancReplaceReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocCancReplaceReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocCancReplaceReason::AllocCancReplaceReason()\n"
    "    FIX::AllocCancReplaceReason::AllocCancReplaceReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocCancReplaceReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocCancReplaceReason *arg1 = (FIX::AllocCancReplaceReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocCancReplaceReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocCancReplaceReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocCancReplaceReason" "', argument " "1"" of type '" "FIX::AllocCancReplaceReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocCancReplaceReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CxlRejReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CxlRejReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CxlRejReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CxlRejReason *)new FIX::CxlRejReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CxlRejReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlRejReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CxlRejReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CxlRejReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CxlRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CxlRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CxlRejReason *)new FIX::CxlRejReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CxlRejReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlRejReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CxlRejReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CxlRejReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CxlRejReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CxlRejReason::CxlRejReason()\n"
    "    FIX::CxlRejReason::CxlRejReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CxlRejReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CxlRejReason *arg1 = (FIX::CxlRejReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CxlRejReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CxlRejReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CxlRejReason" "', argument " "1"" of type '" "FIX::CxlRejReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CxlRejReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BeginString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BeginString *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BeginString")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BeginString *)new FIX::BeginString();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BeginString, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BeginString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BeginString *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BeginString",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BeginString" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BeginString" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BeginString *)new FIX::BeginString((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BeginString, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BeginString(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BeginString__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BeginString__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BeginString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BeginString::BeginString()\n"
    "    FIX::BeginString::BeginString(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BeginString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BeginString *arg1 = (FIX::BeginString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BeginString",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BeginString, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BeginString" "', argument " "1"" of type '" "FIX::BeginString *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BeginString * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DeliverToSubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeliverToSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DeliverToSubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeliverToSubID *)new FIX::DeliverToSubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeliverToSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliverToSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DeliverToSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DeliverToSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeliverToSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeliverToSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeliverToSubID *)new FIX::DeliverToSubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeliverToSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliverToSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DeliverToSubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeliverToSubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DeliverToSubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DeliverToSubID::DeliverToSubID()\n"
    "    FIX::DeliverToSubID::DeliverToSubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DeliverToSubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeliverToSubID *arg1 = (FIX::DeliverToSubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DeliverToSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DeliverToSubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeliverToSubID" "', argument " "1"" of type '" "FIX::DeliverToSubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DeliverToSubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegPriceUnitOfMeasureQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegPriceUnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegPriceUnitOfMeasureQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegPriceUnitOfMeasureQty *)new FIX::LegPriceUnitOfMeasureQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegPriceUnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPriceUnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegPriceUnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegPriceUnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegPriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegPriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegPriceUnitOfMeasureQty *)new FIX::LegPriceUnitOfMeasureQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegPriceUnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPriceUnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegPriceUnitOfMeasureQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegPriceUnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegPriceUnitOfMeasureQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegPriceUnitOfMeasureQty::LegPriceUnitOfMeasureQty()\n"
    "    FIX::LegPriceUnitOfMeasureQty::LegPriceUnitOfMeasureQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegPriceUnitOfMeasureQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegPriceUnitOfMeasureQty *arg1 = (FIX::LegPriceUnitOfMeasureQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegPriceUnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegPriceUnitOfMeasureQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegPriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::LegPriceUnitOfMeasureQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegPriceUnitOfMeasureQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoCollInquiryQualifier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoCollInquiryQualifier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoCollInquiryQualifier")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoCollInquiryQualifier *)new FIX::NoCollInquiryQualifier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoCollInquiryQualifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoCollInquiryQualifier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoCollInquiryQualifier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoCollInquiryQualifier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoCollInquiryQualifier" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoCollInquiryQualifier" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoCollInquiryQualifier *)new FIX::NoCollInquiryQualifier((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoCollInquiryQualifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoCollInquiryQualifier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoCollInquiryQualifier__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoCollInquiryQualifier__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoCollInquiryQualifier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoCollInquiryQualifier::NoCollInquiryQualifier()\n"
    "    FIX::NoCollInquiryQualifier::NoCollInquiryQualifier(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoCollInquiryQualifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoCollInquiryQualifier *arg1 = (FIX::NoCollInquiryQualifier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoCollInquiryQualifier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoCollInquiryQualifier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoCollInquiryQualifier" "', argument " "1"" of type '" "FIX::NoCollInquiryQualifier *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoCollInquiryQualifier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OfferPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OfferPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OfferPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OfferPx *)new FIX::OfferPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OfferPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OfferPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OfferPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OfferPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OfferPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OfferPx *)new FIX::OfferPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OfferPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OfferPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OfferPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OfferPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OfferPx::OfferPx()\n"
    "    FIX::OfferPx::OfferPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OfferPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OfferPx *arg1 = (FIX::OfferPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OfferPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OfferPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OfferPx" "', argument " "1"" of type '" "FIX::OfferPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OfferPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TotalVolumeTradedDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalVolumeTradedDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotalVolumeTradedDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalVolumeTradedDate *)new FIX::TotalVolumeTradedDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalVolumeTradedDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalVolumeTradedDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotalVolumeTradedDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotalVolumeTradedDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotalVolumeTradedDate" "', argument " "1"" of type '" "FIX::UTCDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotalVolumeTradedDate" "', argument " "1"" of type '" "FIX::UTCDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalVolumeTradedDate *)new FIX::TotalVolumeTradedDate((FIX::UTCDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalVolumeTradedDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalVolumeTradedDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotalVolumeTradedDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalVolumeTradedDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotalVolumeTradedDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotalVolumeTradedDate::TotalVolumeTradedDate()\n"
    "    FIX::TotalVolumeTradedDate::TotalVolumeTradedDate(FIX::UTCDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotalVolumeTradedDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalVolumeTradedDate *arg1 = (FIX::TotalVolumeTradedDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotalVolumeTradedDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotalVolumeTradedDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotalVolumeTradedDate" "', argument " "1"" of type '" "FIX::TotalVolumeTradedDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotalVolumeTradedDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoContAmts__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoContAmts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoContAmts")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoContAmts *)new FIX::NoContAmts();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoContAmts, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoContAmts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoContAmts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoContAmts",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoContAmts" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoContAmts" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoContAmts *)new FIX::NoContAmts((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoContAmts, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoContAmts(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoContAmts__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoContAmts__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoContAmts'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoContAmts::NoContAmts()\n"
    "    FIX::NoContAmts::NoContAmts(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoContAmts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoContAmts *arg1 = (FIX::NoContAmts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoContAmts",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoContAmts, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoContAmts" "', argument " "1"" of type '" "FIX::NoContAmts *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoContAmts * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MinOfferSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinOfferSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MinOfferSize")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MinOfferSize *)new FIX::MinOfferSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MinOfferSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinOfferSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MinOfferSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MinOfferSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MinOfferSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MinOfferSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MinOfferSize *)new FIX::MinOfferSize((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MinOfferSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinOfferSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MinOfferSize__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinOfferSize__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MinOfferSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MinOfferSize::MinOfferSize()\n"
    "    FIX::MinOfferSize::MinOfferSize(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MinOfferSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinOfferSize *arg1 = (FIX::MinOfferSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MinOfferSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MinOfferSize, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MinOfferSize" "', argument " "1"" of type '" "FIX::MinOfferSize *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MinOfferSize * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AvgParPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AvgParPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AvgParPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AvgParPx *)new FIX::AvgParPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AvgParPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgParPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AvgParPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AvgParPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AvgParPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AvgParPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AvgParPx *)new FIX::AvgParPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AvgParPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgParPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AvgParPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AvgParPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AvgParPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AvgParPx::AvgParPx()\n"
    "    FIX::AvgParPx::AvgParPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AvgParPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AvgParPx *arg1 = (FIX::AvgParPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AvgParPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AvgParPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AvgParPx" "', argument " "1"" of type '" "FIX::AvgParPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AvgParPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegFactor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegFactor *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegFactor")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegFactor *)new FIX::LegFactor();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegFactor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegFactor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegFactor *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegFactor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegFactor" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegFactor" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegFactor *)new FIX::LegFactor((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegFactor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegFactor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegFactor__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegFactor__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegFactor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegFactor::LegFactor()\n"
    "    FIX::LegFactor::LegFactor(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegFactor *arg1 = (FIX::LegFactor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegFactor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegFactor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegFactor" "', argument " "1"" of type '" "FIX::LegFactor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegFactor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RespondentType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RespondentType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RespondentType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RespondentType *)new FIX::RespondentType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RespondentType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RespondentType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RespondentType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RespondentType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RespondentType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RespondentType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RespondentType *)new FIX::RespondentType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RespondentType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RespondentType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RespondentType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RespondentType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RespondentType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RespondentType::RespondentType()\n"
    "    FIX::RespondentType::RespondentType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RespondentType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RespondentType *arg1 = (FIX::RespondentType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RespondentType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RespondentType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RespondentType" "', argument " "1"" of type '" "FIX::RespondentType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RespondentType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DisplayLowQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DisplayLowQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DisplayLowQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DisplayLowQty *)new FIX::DisplayLowQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DisplayLowQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayLowQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DisplayLowQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DisplayLowQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DisplayLowQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DisplayLowQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DisplayLowQty *)new FIX::DisplayLowQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DisplayLowQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayLowQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DisplayLowQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DisplayLowQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DisplayLowQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DisplayLowQty::DisplayLowQty()\n"
    "    FIX::DisplayLowQty::DisplayLowQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DisplayLowQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DisplayLowQty *arg1 = (FIX::DisplayLowQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DisplayLowQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DisplayLowQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DisplayLowQty" "', argument " "1"" of type '" "FIX::DisplayLowQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DisplayLowQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DKReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DKReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DKReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DKReason *)new FIX::DKReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DKReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DKReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DKReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DKReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DKReason" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DKReason" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DKReason *)new FIX::DKReason((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DKReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DKReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DKReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DKReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DKReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DKReason::DKReason()\n"
    "    FIX::DKReason::DKReason(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DKReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DKReason *arg1 = (FIX::DKReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DKReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DKReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DKReason" "', argument " "1"" of type '" "FIX::DKReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DKReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BenchmarkPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BenchmarkPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BenchmarkPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BenchmarkPrice *)new FIX::BenchmarkPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BenchmarkPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BenchmarkPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BenchmarkPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BenchmarkPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BenchmarkPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BenchmarkPrice *)new FIX::BenchmarkPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BenchmarkPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BenchmarkPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BenchmarkPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BenchmarkPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BenchmarkPrice::BenchmarkPrice()\n"
    "    FIX::BenchmarkPrice::BenchmarkPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BenchmarkPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BenchmarkPrice *arg1 = (FIX::BenchmarkPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BenchmarkPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BenchmarkPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BenchmarkPrice" "', argument " "1"" of type '" "FIX::BenchmarkPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BenchmarkPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ListID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ListID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListID *)new FIX::ListID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ListID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ListID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListID *)new FIX::ListID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ListID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ListID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ListID::ListID()\n"
    "    FIX::ListID::ListID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListID *arg1 = (FIX::ListID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ListID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ListID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListID" "', argument " "1"" of type '" "FIX::ListID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ListID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegSecurityAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSecurityAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecurityAltID *)new FIX::LegSecurityAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecurityAltID *)new FIX::LegSecurityAltID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSecurityAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecurityAltID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSecurityAltID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSecurityAltID::LegSecurityAltID()\n"
    "    FIX::LegSecurityAltID::LegSecurityAltID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSecurityAltID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecurityAltID *arg1 = (FIX::LegSecurityAltID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSecurityAltID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSecurityAltID" "', argument " "1"" of type '" "FIX::LegSecurityAltID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSecurityAltID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PositionEffect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PositionEffect *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PositionEffect")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PositionEffect *)new FIX::PositionEffect();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PositionEffect, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PositionEffect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PositionEffect *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PositionEffect",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PositionEffect" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PositionEffect" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PositionEffect *)new FIX::PositionEffect((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PositionEffect, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PositionEffect(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PositionEffect__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PositionEffect__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PositionEffect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PositionEffect::PositionEffect()\n"
    "    FIX::PositionEffect::PositionEffect(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PositionEffect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PositionEffect *arg1 = (FIX::PositionEffect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PositionEffect",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PositionEffect, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PositionEffect" "', argument " "1"" of type '" "FIX::PositionEffect *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PositionEffect * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TriggerAction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerAction")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerAction *)new FIX::TriggerAction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerAction *)new FIX::TriggerAction((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerAction__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerAction__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerAction::TriggerAction()\n"
    "    FIX::TriggerAction::TriggerAction(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerAction *arg1 = (FIX::TriggerAction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerAction" "', argument " "1"" of type '" "FIX::TriggerAction *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerAction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RefOrderID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefOrderID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefOrderID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefOrderID *)new FIX::RefOrderID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefOrderID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefOrderID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefOrderID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefOrderID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefOrderID *)new FIX::RefOrderID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefOrderID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefOrderID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefOrderID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefOrderID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefOrderID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefOrderID::RefOrderID()\n"
    "    FIX::RefOrderID::RefOrderID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefOrderID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefOrderID *arg1 = (FIX::RefOrderID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefOrderID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefOrderID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefOrderID" "', argument " "1"" of type '" "FIX::RefOrderID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefOrderID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ClearingInstruction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClearingInstruction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ClearingInstruction")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClearingInstruction *)new FIX::ClearingInstruction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClearingInstruction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingInstruction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ClearingInstruction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ClearingInstruction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClearingInstruction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ClearingInstruction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClearingInstruction *)new FIX::ClearingInstruction((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClearingInstruction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingInstruction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ClearingInstruction__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClearingInstruction__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ClearingInstruction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ClearingInstruction::ClearingInstruction()\n"
    "    FIX::ClearingInstruction::ClearingInstruction(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ClearingInstruction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClearingInstruction *arg1 = (FIX::ClearingInstruction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ClearingInstruction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ClearingInstruction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClearingInstruction" "', argument " "1"" of type '" "FIX::ClearingInstruction *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ClearingInstruction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlInstCode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlInstCode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstCode *)new FIX::SettlInstCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlInstCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlInstCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlInstCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlInstCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstCode *)new FIX::SettlInstCode((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlInstCode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstCode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlInstCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlInstCode::SettlInstCode()\n"
    "    FIX::SettlInstCode::SettlInstCode(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlInstCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstCode *arg1 = (FIX::SettlInstCode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlInstCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlInstCode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlInstCode" "', argument " "1"" of type '" "FIX::SettlInstCode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlInstCode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NumDaysInterest__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NumDaysInterest *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NumDaysInterest")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NumDaysInterest *)new FIX::NumDaysInterest();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NumDaysInterest, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumDaysInterest__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NumDaysInterest *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NumDaysInterest",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NumDaysInterest" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NumDaysInterest" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NumDaysInterest *)new FIX::NumDaysInterest((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NumDaysInterest, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumDaysInterest(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NumDaysInterest__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NumDaysInterest__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NumDaysInterest'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NumDaysInterest::NumDaysInterest()\n"
    "    FIX::NumDaysInterest::NumDaysInterest(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NumDaysInterest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NumDaysInterest *arg1 = (FIX::NumDaysInterest *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NumDaysInterest",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NumDaysInterest, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NumDaysInterest" "', argument " "1"" of type '" "FIX::NumDaysInterest *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NumDaysInterest * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OpenCloseSettlFlag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OpenCloseSettlFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OpenCloseSettlFlag")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OpenCloseSettlFlag *)new FIX::OpenCloseSettlFlag();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OpenCloseSettlFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenCloseSettlFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OpenCloseSettlFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OpenCloseSettlFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MULTIPLECHARVALUE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OpenCloseSettlFlag" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OpenCloseSettlFlag" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLECHARVALUE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OpenCloseSettlFlag *)new FIX::OpenCloseSettlFlag((FIX::MULTIPLECHARVALUE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OpenCloseSettlFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenCloseSettlFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OpenCloseSettlFlag__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MULTIPLECHARVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OpenCloseSettlFlag__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OpenCloseSettlFlag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OpenCloseSettlFlag::OpenCloseSettlFlag()\n"
    "    FIX::OpenCloseSettlFlag::OpenCloseSettlFlag(FIX::MULTIPLECHARVALUE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OpenCloseSettlFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OpenCloseSettlFlag *arg1 = (FIX::OpenCloseSettlFlag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OpenCloseSettlFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OpenCloseSettlFlag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OpenCloseSettlFlag" "', argument " "1"" of type '" "FIX::OpenCloseSettlFlag *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OpenCloseSettlFlag * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoComplexEventDates__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoComplexEventDates *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoComplexEventDates")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoComplexEventDates *)new FIX::NoComplexEventDates();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoComplexEventDates, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoComplexEventDates__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoComplexEventDates *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoComplexEventDates",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoComplexEventDates" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoComplexEventDates" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoComplexEventDates *)new FIX::NoComplexEventDates((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoComplexEventDates, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoComplexEventDates(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoComplexEventDates__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoComplexEventDates__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoComplexEventDates'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoComplexEventDates::NoComplexEventDates()\n"
    "    FIX::NoComplexEventDates::NoComplexEventDates(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoComplexEventDates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoComplexEventDates *arg1 = (FIX::NoComplexEventDates *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoComplexEventDates",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoComplexEventDates, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoComplexEventDates" "', argument " "1"" of type '" "FIX::NoComplexEventDates *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoComplexEventDates * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeEncodedIssuerLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEncodedIssuerLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeEncodedIssuerLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEncodedIssuerLen *)new FIX::DerivativeEncodedIssuerLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEncodedIssuerLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedIssuerLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeEncodedIssuerLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeEncodedIssuerLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeEncodedIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeEncodedIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEncodedIssuerLen *)new FIX::DerivativeEncodedIssuerLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEncodedIssuerLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedIssuerLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeEncodedIssuerLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEncodedIssuerLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeEncodedIssuerLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeEncodedIssuerLen::DerivativeEncodedIssuerLen()\n"
    "    FIX::DerivativeEncodedIssuerLen::DerivativeEncodedIssuerLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeEncodedIssuerLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEncodedIssuerLen *arg1 = (FIX::DerivativeEncodedIssuerLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeEncodedIssuerLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeEncodedIssuerLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeEncodedIssuerLen" "', argument " "1"" of type '" "FIX::DerivativeEncodedIssuerLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeEncodedIssuerLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StrikeMultiplier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikeMultiplier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StrikeMultiplier")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeMultiplier *)new FIX::StrikeMultiplier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeMultiplier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrikeMultiplier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrikeMultiplier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrikeMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrikeMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeMultiplier *)new FIX::StrikeMultiplier((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeMultiplier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StrikeMultiplier__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikeMultiplier__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StrikeMultiplier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StrikeMultiplier::StrikeMultiplier()\n"
    "    FIX::StrikeMultiplier::StrikeMultiplier(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StrikeMultiplier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikeMultiplier *arg1 = (FIX::StrikeMultiplier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrikeMultiplier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StrikeMultiplier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrikeMultiplier" "', argument " "1"" of type '" "FIX::StrikeMultiplier *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StrikeMultiplier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DiscretionMoveType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionMoveType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DiscretionMoveType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionMoveType *)new FIX::DiscretionMoveType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionMoveType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionMoveType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DiscretionMoveType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DiscretionMoveType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscretionMoveType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretionMoveType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionMoveType *)new FIX::DiscretionMoveType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionMoveType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionMoveType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DiscretionMoveType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionMoveType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DiscretionMoveType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DiscretionMoveType::DiscretionMoveType()\n"
    "    FIX::DiscretionMoveType::DiscretionMoveType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DiscretionMoveType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionMoveType *arg1 = (FIX::DiscretionMoveType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DiscretionMoveType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DiscretionMoveType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscretionMoveType" "', argument " "1"" of type '" "FIX::DiscretionMoveType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DiscretionMoveType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ListNoOrds__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListNoOrds *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ListNoOrds")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListNoOrds *)new FIX::ListNoOrds();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListNoOrds, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListNoOrds__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ListNoOrds *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ListNoOrds",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListNoOrds" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListNoOrds" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListNoOrds *)new FIX::ListNoOrds((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListNoOrds, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListNoOrds(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ListNoOrds__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListNoOrds__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ListNoOrds'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ListNoOrds::ListNoOrds()\n"
    "    FIX::ListNoOrds::ListNoOrds(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListNoOrds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListNoOrds *arg1 = (FIX::ListNoOrds *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ListNoOrds",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ListNoOrds, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListNoOrds" "', argument " "1"" of type '" "FIX::ListNoOrds *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ListNoOrds * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PegSymbol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegSymbol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PegSymbol")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegSymbol *)new FIX::PegSymbol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegSymbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSymbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PegSymbol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PegSymbol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PegSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PegSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegSymbol *)new FIX::PegSymbol((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegSymbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PegSymbol__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegSymbol__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PegSymbol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PegSymbol::PegSymbol()\n"
    "    FIX::PegSymbol::PegSymbol(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PegSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegSymbol *arg1 = (FIX::PegSymbol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PegSymbol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PegSymbol, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PegSymbol" "', argument " "1"" of type '" "FIX::PegSymbol *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PegSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DayAvgPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DayAvgPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DayAvgPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DayAvgPx *)new FIX::DayAvgPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DayAvgPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayAvgPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DayAvgPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DayAvgPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DayAvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DayAvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DayAvgPx *)new FIX::DayAvgPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DayAvgPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayAvgPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DayAvgPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DayAvgPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DayAvgPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DayAvgPx::DayAvgPx()\n"
    "    FIX::DayAvgPx::DayAvgPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DayAvgPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DayAvgPx *arg1 = (FIX::DayAvgPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DayAvgPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DayAvgPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DayAvgPx" "', argument " "1"" of type '" "FIX::DayAvgPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DayAvgPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Headline__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Headline *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Headline")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Headline *)new FIX::Headline();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Headline, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Headline__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Headline *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Headline",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Headline" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Headline" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Headline *)new FIX::Headline((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Headline, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Headline(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Headline__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Headline__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Headline'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Headline::Headline()\n"
    "    FIX::Headline::Headline(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Headline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Headline *arg1 = (FIX::Headline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Headline",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Headline, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Headline" "', argument " "1"" of type '" "FIX::Headline *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Headline * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NestedPartySubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NestedPartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NestedPartySubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NestedPartySubID *)new FIX::NestedPartySubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NestedPartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NestedPartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NestedPartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NestedPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NestedPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NestedPartySubID *)new FIX::NestedPartySubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NestedPartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NestedPartySubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NestedPartySubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NestedPartySubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NestedPartySubID::NestedPartySubID()\n"
    "    FIX::NestedPartySubID::NestedPartySubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NestedPartySubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NestedPartySubID *arg1 = (FIX::NestedPartySubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NestedPartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NestedPartySubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NestedPartySubID" "', argument " "1"" of type '" "FIX::NestedPartySubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NestedPartySubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CardIssNo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CardIssNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CardIssNo")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CardIssNo *)new FIX::CardIssNo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CardIssNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardIssNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CardIssNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CardIssNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CardIssNo" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CardIssNo" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CardIssNo *)new FIX::CardIssNo((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CardIssNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardIssNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CardIssNo__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CardIssNo__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CardIssNo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CardIssNo::CardIssNo()\n"
    "    FIX::CardIssNo::CardIssNo(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CardIssNo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CardIssNo *arg1 = (FIX::CardIssNo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CardIssNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CardIssNo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CardIssNo" "', argument " "1"" of type '" "FIX::CardIssNo *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CardIssNo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OptAttribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OptAttribute *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OptAttribute")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OptAttribute *)new FIX::OptAttribute();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OptAttribute, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OptAttribute *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OptAttribute",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OptAttribute *)new FIX::OptAttribute((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OptAttribute, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptAttribute(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OptAttribute__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OptAttribute__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OptAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OptAttribute::OptAttribute()\n"
    "    FIX::OptAttribute::OptAttribute(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OptAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OptAttribute *arg1 = (FIX::OptAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OptAttribute",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OptAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptAttribute" "', argument " "1"" of type '" "FIX::OptAttribute *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OptAttribute * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LastForwardPoints2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastForwardPoints2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastForwardPoints2")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastForwardPoints2 *)new FIX::LastForwardPoints2();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastForwardPoints2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastForwardPoints2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastForwardPoints2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastForwardPoints2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastForwardPoints2" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastForwardPoints2" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastForwardPoints2 *)new FIX::LastForwardPoints2((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastForwardPoints2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastForwardPoints2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastForwardPoints2__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastForwardPoints2__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastForwardPoints2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastForwardPoints2::LastForwardPoints2()\n"
    "    FIX::LastForwardPoints2::LastForwardPoints2(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastForwardPoints2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastForwardPoints2 *arg1 = (FIX::LastForwardPoints2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastForwardPoints2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastForwardPoints2, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastForwardPoints2" "', argument " "1"" of type '" "FIX::LastForwardPoints2 *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastForwardPoints2 * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDUpdateType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDUpdateType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDUpdateType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDUpdateType *)new FIX::MDUpdateType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDUpdateType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDUpdateType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDUpdateType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDUpdateType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDUpdateType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDUpdateType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDUpdateType *)new FIX::MDUpdateType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDUpdateType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDUpdateType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDUpdateType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDUpdateType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDUpdateType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDUpdateType::MDUpdateType()\n"
    "    FIX::MDUpdateType::MDUpdateType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDUpdateType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDUpdateType *arg1 = (FIX::MDUpdateType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDUpdateType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDUpdateType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDUpdateType" "', argument " "1"" of type '" "FIX::MDUpdateType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDUpdateType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TickDirection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TickDirection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TickDirection")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TickDirection *)new FIX::TickDirection();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TickDirection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TickDirection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TickDirection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TickDirection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TickDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TickDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TickDirection *)new FIX::TickDirection((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TickDirection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TickDirection(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TickDirection__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TickDirection__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TickDirection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TickDirection::TickDirection()\n"
    "    FIX::TickDirection::TickDirection(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TickDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TickDirection *arg1 = (FIX::TickDirection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TickDirection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TickDirection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TickDirection" "', argument " "1"" of type '" "FIX::TickDirection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TickDirection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegRedemptionDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegRedemptionDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegRedemptionDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegRedemptionDate *)new FIX::LegRedemptionDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegRedemptionDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRedemptionDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegRedemptionDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegRedemptionDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegRedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegRedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegRedemptionDate *)new FIX::LegRedemptionDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegRedemptionDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRedemptionDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegRedemptionDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegRedemptionDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegRedemptionDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegRedemptionDate::LegRedemptionDate()\n"
    "    FIX::LegRedemptionDate::LegRedemptionDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegRedemptionDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegRedemptionDate *arg1 = (FIX::LegRedemptionDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegRedemptionDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegRedemptionDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegRedemptionDate" "', argument " "1"" of type '" "FIX::LegRedemptionDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegRedemptionDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StrikePrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StrikePrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikePrice *)new FIX::StrikePrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrikePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrikePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikePrice *)new FIX::StrikePrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StrikePrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikePrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StrikePrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StrikePrice::StrikePrice()\n"
    "    FIX::StrikePrice::StrikePrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StrikePrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikePrice *arg1 = (FIX::StrikePrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrikePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StrikePrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrikePrice" "', argument " "1"" of type '" "FIX::StrikePrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StrikePrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedIssuer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedIssuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedIssuer")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedIssuer *)new FIX::EncodedIssuer();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedIssuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedIssuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedIssuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedIssuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedIssuer *)new FIX::EncodedIssuer((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedIssuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedIssuer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedIssuer__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedIssuer__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedIssuer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedIssuer::EncodedIssuer()\n"
    "    FIX::EncodedIssuer::EncodedIssuer(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedIssuer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedIssuer *arg1 = (FIX::EncodedIssuer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedIssuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedIssuer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedIssuer" "', argument " "1"" of type '" "FIX::EncodedIssuer *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedIssuer * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_YieldType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::YieldType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_YieldType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::YieldType *)new FIX::YieldType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__YieldType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::YieldType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_YieldType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YieldType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YieldType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::YieldType *)new FIX::YieldType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__YieldType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_YieldType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YieldType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_YieldType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::YieldType::YieldType()\n"
    "    FIX::YieldType::YieldType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YieldType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::YieldType *arg1 = (FIX::YieldType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_YieldType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__YieldType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YieldType" "', argument " "1"" of type '" "FIX::YieldType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::YieldType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradingReferencePrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradingReferencePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradingReferencePrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradingReferencePrice *)new FIX::TradingReferencePrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradingReferencePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingReferencePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradingReferencePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradingReferencePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradingReferencePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradingReferencePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradingReferencePrice *)new FIX::TradingReferencePrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradingReferencePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingReferencePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradingReferencePrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradingReferencePrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradingReferencePrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradingReferencePrice::TradingReferencePrice()\n"
    "    FIX::TradingReferencePrice::TradingReferencePrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradingReferencePrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradingReferencePrice *arg1 = (FIX::TradingReferencePrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradingReferencePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradingReferencePrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradingReferencePrice" "', argument " "1"" of type '" "FIX::TradingReferencePrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradingReferencePrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDEntrySpotRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntrySpotRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDEntrySpotRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntrySpotRate *)new FIX::MDEntrySpotRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntrySpotRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntrySpotRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDEntrySpotRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDEntrySpotRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDEntrySpotRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDEntrySpotRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntrySpotRate *)new FIX::MDEntrySpotRate((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntrySpotRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntrySpotRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDEntrySpotRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntrySpotRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDEntrySpotRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDEntrySpotRate::MDEntrySpotRate()\n"
    "    FIX::MDEntrySpotRate::MDEntrySpotRate(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDEntrySpotRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntrySpotRate *arg1 = (FIX::MDEntrySpotRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDEntrySpotRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDEntrySpotRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDEntrySpotRate" "', argument " "1"" of type '" "FIX::MDEntrySpotRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDEntrySpotRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ParticipationRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ParticipationRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ParticipationRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ParticipationRate *)new FIX::ParticipationRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ParticipationRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticipationRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ParticipationRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ParticipationRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParticipationRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParticipationRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ParticipationRate *)new FIX::ParticipationRate((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ParticipationRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticipationRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ParticipationRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ParticipationRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ParticipationRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ParticipationRate::ParticipationRate()\n"
    "    FIX::ParticipationRate::ParticipationRate(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ParticipationRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ParticipationRate *arg1 = (FIX::ParticipationRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ParticipationRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ParticipationRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ParticipationRate" "', argument " "1"" of type '" "FIX::ParticipationRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ParticipationRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PegScope__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegScope *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PegScope")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegScope *)new FIX::PegScope();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegScope, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegScope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PegScope *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PegScope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PegScope" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PegScope" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegScope *)new FIX::PegScope((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegScope, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegScope(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PegScope__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegScope__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PegScope'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PegScope::PegScope()\n"
    "    FIX::PegScope::PegScope(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PegScope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegScope *arg1 = (FIX::PegScope *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PegScope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PegScope, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PegScope" "', argument " "1"" of type '" "FIX::PegScope *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PegScope * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_InterestAtMaturity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InterestAtMaturity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InterestAtMaturity")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InterestAtMaturity *)new FIX::InterestAtMaturity();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InterestAtMaturity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterestAtMaturity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InterestAtMaturity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InterestAtMaturity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InterestAtMaturity" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterestAtMaturity" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InterestAtMaturity *)new FIX::InterestAtMaturity((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InterestAtMaturity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterestAtMaturity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InterestAtMaturity__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InterestAtMaturity__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InterestAtMaturity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InterestAtMaturity::InterestAtMaturity()\n"
    "    FIX::InterestAtMaturity::InterestAtMaturity(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InterestAtMaturity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InterestAtMaturity *arg1 = (FIX::InterestAtMaturity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InterestAtMaturity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InterestAtMaturity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InterestAtMaturity" "', argument " "1"" of type '" "FIX::InterestAtMaturity *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InterestAtMaturity * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegIndividualAllocID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegIndividualAllocID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegIndividualAllocID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegIndividualAllocID *)new FIX::LegIndividualAllocID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegIndividualAllocID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIndividualAllocID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegIndividualAllocID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegIndividualAllocID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegIndividualAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegIndividualAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegIndividualAllocID *)new FIX::LegIndividualAllocID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegIndividualAllocID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIndividualAllocID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegIndividualAllocID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegIndividualAllocID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegIndividualAllocID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegIndividualAllocID::LegIndividualAllocID()\n"
    "    FIX::LegIndividualAllocID::LegIndividualAllocID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegIndividualAllocID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegIndividualAllocID *arg1 = (FIX::LegIndividualAllocID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegIndividualAllocID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegIndividualAllocID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegIndividualAllocID" "', argument " "1"" of type '" "FIX::LegIndividualAllocID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegIndividualAllocID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllowableOneSidednessValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllowableOneSidednessValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllowableOneSidednessValue *)new FIX::AllowableOneSidednessValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllowableOneSidednessValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllowableOneSidednessValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllowableOneSidednessValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllowableOneSidednessValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllowableOneSidednessValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllowableOneSidednessValue *)new FIX::AllowableOneSidednessValue((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllowableOneSidednessValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllowableOneSidednessValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllowableOneSidednessValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllowableOneSidednessValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllowableOneSidednessValue::AllowableOneSidednessValue()\n"
    "    FIX::AllowableOneSidednessValue::AllowableOneSidednessValue(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllowableOneSidednessValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllowableOneSidednessValue *arg1 = (FIX::AllowableOneSidednessValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllowableOneSidednessValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllowableOneSidednessValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllowableOneSidednessValue" "', argument " "1"" of type '" "FIX::AllowableOneSidednessValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllowableOneSidednessValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CashSettlAgentName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashSettlAgentName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashSettlAgentName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashSettlAgentName *)new FIX::CashSettlAgentName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashSettlAgentName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashSettlAgentName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashSettlAgentName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashSettlAgentName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashSettlAgentName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashSettlAgentName *)new FIX::CashSettlAgentName((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashSettlAgentName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashSettlAgentName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashSettlAgentName__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashSettlAgentName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashSettlAgentName::CashSettlAgentName()\n"
    "    FIX::CashSettlAgentName::CashSettlAgentName(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashSettlAgentName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashSettlAgentName *arg1 = (FIX::CashSettlAgentName *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashSettlAgentName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashSettlAgentName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashSettlAgentName" "', argument " "1"" of type '" "FIX::CashSettlAgentName *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashSettlAgentName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ContraTradeQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContraTradeQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ContraTradeQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContraTradeQty *)new FIX::ContraTradeQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContraTradeQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTradeQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContraTradeQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContraTradeQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContraTradeQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContraTradeQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContraTradeQty *)new FIX::ContraTradeQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContraTradeQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTradeQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ContraTradeQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContraTradeQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContraTradeQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ContraTradeQty::ContraTradeQty()\n"
    "    FIX::ContraTradeQty::ContraTradeQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ContraTradeQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContraTradeQty *arg1 = (FIX::ContraTradeQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContraTradeQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ContraTradeQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContraTradeQty" "', argument " "1"" of type '" "FIX::ContraTradeQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ContraTradeQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegMaturityTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegMaturityTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegMaturityTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegMaturityTime *)new FIX::LegMaturityTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegMaturityTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegMaturityTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTIMEONLY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegMaturityTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegMaturityTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__TZTIMEONLY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMEONLY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegMaturityTime *)new FIX::LegMaturityTime((FIX::TZTIMEONLY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegMaturityTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegMaturityTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegMaturityTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__TZTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegMaturityTime__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegMaturityTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegMaturityTime::LegMaturityTime()\n"
    "    FIX::LegMaturityTime::LegMaturityTime(FIX::TZTIMEONLY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegMaturityTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegMaturityTime *arg1 = (FIX::LegMaturityTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegMaturityTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegMaturityTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegMaturityTime" "', argument " "1"" of type '" "FIX::LegMaturityTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegMaturityTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlDeliveryType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlDeliveryType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlDeliveryType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlDeliveryType *)new FIX::SettlDeliveryType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlDeliveryType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDeliveryType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlDeliveryType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlDeliveryType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlDeliveryType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlDeliveryType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlDeliveryType *)new FIX::SettlDeliveryType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlDeliveryType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDeliveryType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlDeliveryType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlDeliveryType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlDeliveryType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlDeliveryType::SettlDeliveryType()\n"
    "    FIX::SettlDeliveryType::SettlDeliveryType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlDeliveryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlDeliveryType *arg1 = (FIX::SettlDeliveryType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlDeliveryType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlDeliveryType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlDeliveryType" "', argument " "1"" of type '" "FIX::SettlDeliveryType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlDeliveryType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecondaryPriceLimitType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryPriceLimitType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryPriceLimitType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryPriceLimitType *)new FIX::SecondaryPriceLimitType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryPriceLimitType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryPriceLimitType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryPriceLimitType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryPriceLimitType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryPriceLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryPriceLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryPriceLimitType *)new FIX::SecondaryPriceLimitType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryPriceLimitType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryPriceLimitType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryPriceLimitType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryPriceLimitType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryPriceLimitType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryPriceLimitType::SecondaryPriceLimitType()\n"
    "    FIX::SecondaryPriceLimitType::SecondaryPriceLimitType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryPriceLimitType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryPriceLimitType *arg1 = (FIX::SecondaryPriceLimitType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryPriceLimitType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryPriceLimitType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryPriceLimitType" "', argument " "1"" of type '" "FIX::SecondaryPriceLimitType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryPriceLimitType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MidPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MidPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MidPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MidPx *)new FIX::MidPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MidPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MidPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MidPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MidPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MidPx *)new FIX::MidPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MidPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MidPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MidPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MidPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MidPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MidPx::MidPx()\n"
    "    FIX::MidPx::MidPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MidPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MidPx *arg1 = (FIX::MidPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MidPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MidPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MidPx" "', argument " "1"" of type '" "FIX::MidPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MidPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AvgPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AvgPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AvgPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AvgPx *)new FIX::AvgPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AvgPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AvgPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AvgPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AvgPx *)new FIX::AvgPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AvgPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AvgPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AvgPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AvgPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AvgPx::AvgPx()\n"
    "    FIX::AvgPx::AvgPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AvgPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AvgPx *arg1 = (FIX::AvgPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AvgPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AvgPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AvgPx" "', argument " "1"" of type '" "FIX::AvgPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AvgPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DiscretionLimitType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionLimitType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DiscretionLimitType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionLimitType *)new FIX::DiscretionLimitType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionLimitType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionLimitType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DiscretionLimitType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DiscretionLimitType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscretionLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretionLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionLimitType *)new FIX::DiscretionLimitType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionLimitType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionLimitType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DiscretionLimitType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionLimitType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DiscretionLimitType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DiscretionLimitType::DiscretionLimitType()\n"
    "    FIX::DiscretionLimitType::DiscretionLimitType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DiscretionLimitType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionLimitType *arg1 = (FIX::DiscretionLimitType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DiscretionLimitType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DiscretionLimitType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscretionLimitType" "', argument " "1"" of type '" "FIX::DiscretionLimitType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DiscretionLimitType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StrikeTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikeTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StrikeTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeTime *)new FIX::StrikeTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrikeTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrikeTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StrikeTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeTime *)new FIX::StrikeTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrikeTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrikeTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrikeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrikeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeTime *)new FIX::StrikeTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::StrikeTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_StrikeTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrikeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrikeTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StrikeTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeTime *)new FIX::StrikeTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StrikeTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikeTime__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_StrikeTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_StrikeTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StrikeTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StrikeTime::StrikeTime()\n"
    "    FIX::StrikeTime::StrikeTime(bool)\n"
    "    FIX::StrikeTime::StrikeTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::StrikeTime::StrikeTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StrikeTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikeTime *arg1 = (FIX::StrikeTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrikeTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StrikeTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrikeTime" "', argument " "1"" of type '" "FIX::StrikeTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StrikeTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlSessSubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlSessSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlSessSubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlSessSubID *)new FIX::SettlSessSubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlSessSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlSessSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlSessSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlSessSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlSessSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlSessSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlSessSubID *)new FIX::SettlSessSubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlSessSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlSessSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlSessSubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlSessSubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlSessSubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlSessSubID::SettlSessSubID()\n"
    "    FIX::SettlSessSubID::SettlSessSubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlSessSubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlSessSubID *arg1 = (FIX::SettlSessSubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlSessSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlSessSubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlSessSubID" "', argument " "1"" of type '" "FIX::SettlSessSubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlSessSubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MailingDtls__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MailingDtls *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MailingDtls")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MailingDtls *)new FIX::MailingDtls();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MailingDtls, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MailingDtls__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MailingDtls *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MailingDtls",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MailingDtls" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MailingDtls" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MailingDtls *)new FIX::MailingDtls((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MailingDtls, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MailingDtls(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MailingDtls__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MailingDtls__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MailingDtls'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MailingDtls::MailingDtls()\n"
    "    FIX::MailingDtls::MailingDtls(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MailingDtls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MailingDtls *arg1 = (FIX::MailingDtls *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MailingDtls",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MailingDtls, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MailingDtls" "', argument " "1"" of type '" "FIX::MailingDtls *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MailingDtls * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BidID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BidID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidID *)new FIX::BidID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BidID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BidID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BidID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BidID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidID *)new FIX::BidID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BidID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BidID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BidID::BidID()\n"
    "    FIX::BidID::BidID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BidID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidID *arg1 = (FIX::BidID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BidID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BidID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BidID" "', argument " "1"" of type '" "FIX::BidID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BidID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ExerciseMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExerciseMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExerciseMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExerciseMethod *)new FIX::ExerciseMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExerciseMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExerciseMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExerciseMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExerciseMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExerciseMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExerciseMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExerciseMethod *)new FIX::ExerciseMethod((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExerciseMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExerciseMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExerciseMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExerciseMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExerciseMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExerciseMethod::ExerciseMethod()\n"
    "    FIX::ExerciseMethod::ExerciseMethod(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExerciseMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExerciseMethod *arg1 = (FIX::ExerciseMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExerciseMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExerciseMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExerciseMethod" "', argument " "1"" of type '" "FIX::ExerciseMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExerciseMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CommCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CommCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CommCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CommCurrency *)new FIX::CommCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CommCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CommCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CommCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CommCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CommCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CommCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CommCurrency *)new FIX::CommCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CommCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CommCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CommCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CommCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CommCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CommCurrency::CommCurrency()\n"
    "    FIX::CommCurrency::CommCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CommCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CommCurrency *arg1 = (FIX::CommCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CommCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CommCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CommCurrency" "', argument " "1"" of type '" "FIX::CommCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CommCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoSettlOblig__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSettlOblig *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoSettlOblig")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSettlOblig *)new FIX::NoSettlOblig();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSettlOblig, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlOblig__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoSettlOblig *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoSettlOblig",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoSettlOblig" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoSettlOblig" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSettlOblig *)new FIX::NoSettlOblig((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSettlOblig, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlOblig(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoSettlOblig__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSettlOblig__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoSettlOblig'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoSettlOblig::NoSettlOblig()\n"
    "    FIX::NoSettlOblig::NoSettlOblig(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoSettlOblig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSettlOblig *arg1 = (FIX::NoSettlOblig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoSettlOblig",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoSettlOblig, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoSettlOblig" "', argument " "1"" of type '" "FIX::NoSettlOblig *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoSettlOblig * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MaxPriceVariation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaxPriceVariation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaxPriceVariation")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaxPriceVariation *)new FIX::MaxPriceVariation();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaxPriceVariation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxPriceVariation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaxPriceVariation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaxPriceVariation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaxPriceVariation" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaxPriceVariation" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaxPriceVariation *)new FIX::MaxPriceVariation((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaxPriceVariation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxPriceVariation(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaxPriceVariation__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaxPriceVariation__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaxPriceVariation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaxPriceVariation::MaxPriceVariation()\n"
    "    FIX::MaxPriceVariation::MaxPriceVariation(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaxPriceVariation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaxPriceVariation *arg1 = (FIX::MaxPriceVariation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaxPriceVariation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaxPriceVariation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaxPriceVariation" "', argument " "1"" of type '" "FIX::MaxPriceVariation *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaxPriceVariation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_WorkingIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::WorkingIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_WorkingIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::WorkingIndicator *)new FIX::WorkingIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__WorkingIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WorkingIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::WorkingIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_WorkingIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WorkingIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_WorkingIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::WorkingIndicator *)new FIX::WorkingIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__WorkingIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WorkingIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_WorkingIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_WorkingIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_WorkingIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::WorkingIndicator::WorkingIndicator()\n"
    "    FIX::WorkingIndicator::WorkingIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_WorkingIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::WorkingIndicator *arg1 = (FIX::WorkingIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_WorkingIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__WorkingIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WorkingIndicator" "', argument " "1"" of type '" "FIX::WorkingIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::WorkingIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CashSettlAgentAcctName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashSettlAgentAcctName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashSettlAgentAcctName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashSettlAgentAcctName *)new FIX::CashSettlAgentAcctName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashSettlAgentAcctName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentAcctName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashSettlAgentAcctName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashSettlAgentAcctName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashSettlAgentAcctName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashSettlAgentAcctName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashSettlAgentAcctName *)new FIX::CashSettlAgentAcctName((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashSettlAgentAcctName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentAcctName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashSettlAgentAcctName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashSettlAgentAcctName__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashSettlAgentAcctName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashSettlAgentAcctName::CashSettlAgentAcctName()\n"
    "    FIX::CashSettlAgentAcctName::CashSettlAgentAcctName(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashSettlAgentAcctName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashSettlAgentAcctName *arg1 = (FIX::CashSettlAgentAcctName *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashSettlAgentAcctName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashSettlAgentAcctName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashSettlAgentAcctName" "', argument " "1"" of type '" "FIX::CashSettlAgentAcctName *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashSettlAgentAcctName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SellVolume__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SellVolume *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SellVolume")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SellVolume *)new FIX::SellVolume();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SellVolume, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SellVolume__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SellVolume *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SellVolume",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SellVolume" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SellVolume" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SellVolume *)new FIX::SellVolume((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SellVolume, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SellVolume(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SellVolume__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SellVolume__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SellVolume'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SellVolume::SellVolume()\n"
    "    FIX::SellVolume::SellVolume(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SellVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SellVolume *arg1 = (FIX::SellVolume *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SellVolume",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SellVolume, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SellVolume" "', argument " "1"" of type '" "FIX::SellVolume *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SellVolume * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SideMultiLegReportingType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideMultiLegReportingType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideMultiLegReportingType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideMultiLegReportingType *)new FIX::SideMultiLegReportingType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideMultiLegReportingType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideMultiLegReportingType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideMultiLegReportingType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideMultiLegReportingType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideMultiLegReportingType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideMultiLegReportingType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideMultiLegReportingType *)new FIX::SideMultiLegReportingType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideMultiLegReportingType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideMultiLegReportingType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideMultiLegReportingType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideMultiLegReportingType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideMultiLegReportingType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideMultiLegReportingType::SideMultiLegReportingType()\n"
    "    FIX::SideMultiLegReportingType::SideMultiLegReportingType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideMultiLegReportingType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideMultiLegReportingType *arg1 = (FIX::SideMultiLegReportingType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideMultiLegReportingType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideMultiLegReportingType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideMultiLegReportingType" "', argument " "1"" of type '" "FIX::SideMultiLegReportingType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideMultiLegReportingType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeEventText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEventText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeEventText")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEventText *)new FIX::DerivativeEventText();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEventText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeEventText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeEventText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeEventText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeEventText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEventText *)new FIX::DerivativeEventText((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEventText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeEventText__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEventText__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeEventText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeEventText::DerivativeEventText()\n"
    "    FIX::DerivativeEventText::DerivativeEventText(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeEventText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEventText *arg1 = (FIX::DerivativeEventText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeEventText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeEventText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeEventText" "', argument " "1"" of type '" "FIX::DerivativeEventText *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeEventText * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PegSecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PegSecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegSecurityDesc *)new FIX::PegSecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PegSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PegSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PegSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PegSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegSecurityDesc *)new FIX::PegSecurityDesc((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PegSecurityDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegSecurityDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PegSecurityDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PegSecurityDesc::PegSecurityDesc()\n"
    "    FIX::PegSecurityDesc::PegSecurityDesc(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PegSecurityDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegSecurityDesc *arg1 = (FIX::PegSecurityDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PegSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PegSecurityDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PegSecurityDesc" "', argument " "1"" of type '" "FIX::PegSecurityDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PegSecurityDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AllocCustomerCapacity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocCustomerCapacity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocCustomerCapacity")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocCustomerCapacity *)new FIX::AllocCustomerCapacity();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocCustomerCapacity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocCustomerCapacity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocCustomerCapacity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocCustomerCapacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocCustomerCapacity" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocCustomerCapacity" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocCustomerCapacity *)new FIX::AllocCustomerCapacity((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocCustomerCapacity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocCustomerCapacity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocCustomerCapacity__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocCustomerCapacity__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocCustomerCapacity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocCustomerCapacity::AllocCustomerCapacity()\n"
    "    FIX::AllocCustomerCapacity::AllocCustomerCapacity(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocCustomerCapacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocCustomerCapacity *arg1 = (FIX::AllocCustomerCapacity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocCustomerCapacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocCustomerCapacity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocCustomerCapacity" "', argument " "1"" of type '" "FIX::AllocCustomerCapacity *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocCustomerCapacity * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ConfirmRejReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfirmRejReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ConfirmRejReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfirmRejReason *)new FIX::ConfirmRejReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfirmRejReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmRejReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ConfirmRejReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ConfirmRejReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfirmRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConfirmRejReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfirmRejReason *)new FIX::ConfirmRejReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfirmRejReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmRejReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ConfirmRejReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfirmRejReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ConfirmRejReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ConfirmRejReason::ConfirmRejReason()\n"
    "    FIX::ConfirmRejReason::ConfirmRejReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConfirmRejReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfirmRejReason *arg1 = (FIX::ConfirmRejReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ConfirmRejReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ConfirmRejReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfirmRejReason" "', argument " "1"" of type '" "FIX::ConfirmRejReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ConfirmRejReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BidRequestTransType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidRequestTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BidRequestTransType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidRequestTransType *)new FIX::BidRequestTransType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidRequestTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidRequestTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BidRequestTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BidRequestTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BidRequestTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BidRequestTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidRequestTransType *)new FIX::BidRequestTransType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidRequestTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidRequestTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BidRequestTransType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidRequestTransType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BidRequestTransType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BidRequestTransType::BidRequestTransType()\n"
    "    FIX::BidRequestTransType::BidRequestTransType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BidRequestTransType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidRequestTransType *arg1 = (FIX::BidRequestTransType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BidRequestTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BidRequestTransType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BidRequestTransType" "', argument " "1"" of type '" "FIX::BidRequestTransType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BidRequestTransType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CashDistribAgentAcctNumber__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashDistribAgentAcctNumber *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashDistribAgentAcctNumber")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashDistribAgentAcctNumber *)new FIX::CashDistribAgentAcctNumber();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashDistribAgentAcctNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentAcctNumber__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashDistribAgentAcctNumber *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashDistribAgentAcctNumber",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashDistribAgentAcctNumber" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashDistribAgentAcctNumber" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashDistribAgentAcctNumber *)new FIX::CashDistribAgentAcctNumber((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashDistribAgentAcctNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentAcctNumber(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashDistribAgentAcctNumber__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashDistribAgentAcctNumber__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashDistribAgentAcctNumber'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashDistribAgentAcctNumber::CashDistribAgentAcctNumber()\n"
    "    FIX::CashDistribAgentAcctNumber::CashDistribAgentAcctNumber(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashDistribAgentAcctNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashDistribAgentAcctNumber *arg1 = (FIX::CashDistribAgentAcctNumber *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashDistribAgentAcctNumber",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashDistribAgentAcctNumber, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashDistribAgentAcctNumber" "', argument " "1"" of type '" "FIX::CashDistribAgentAcctNumber *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashDistribAgentAcctNumber * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegExecInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegExecInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegExecInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegExecInst *)new FIX::LegExecInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegExecInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegExecInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegExecInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegExecInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MULTIPLECHARVALUE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegExecInst" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegExecInst" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLECHARVALUE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegExecInst *)new FIX::LegExecInst((FIX::MULTIPLECHARVALUE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegExecInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegExecInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegExecInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MULTIPLECHARVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegExecInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegExecInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegExecInst::LegExecInst()\n"
    "    FIX::LegExecInst::LegExecInst(FIX::MULTIPLECHARVALUE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegExecInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegExecInst *arg1 = (FIX::LegExecInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegExecInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegExecInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegExecInst" "', argument " "1"" of type '" "FIX::LegExecInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegExecInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CapPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CapPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CapPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CapPrice *)new FIX::CapPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CapPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CapPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CapPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CapPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CapPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CapPrice *)new FIX::CapPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CapPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CapPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CapPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CapPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CapPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CapPrice::CapPrice()\n"
    "    FIX::CapPrice::CapPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CapPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CapPrice *arg1 = (FIX::CapPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CapPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CapPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CapPrice" "', argument " "1"" of type '" "FIX::CapPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CapPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegRepurchaseTerm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegRepurchaseTerm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegRepurchaseTerm")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegRepurchaseTerm *)new FIX::LegRepurchaseTerm();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegRepurchaseTerm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRepurchaseTerm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegRepurchaseTerm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegRepurchaseTerm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegRepurchaseTerm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegRepurchaseTerm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegRepurchaseTerm *)new FIX::LegRepurchaseTerm((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegRepurchaseTerm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRepurchaseTerm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegRepurchaseTerm__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegRepurchaseTerm__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegRepurchaseTerm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegRepurchaseTerm::LegRepurchaseTerm()\n"
    "    FIX::LegRepurchaseTerm::LegRepurchaseTerm(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegRepurchaseTerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegRepurchaseTerm *arg1 = (FIX::LegRepurchaseTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegRepurchaseTerm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegRepurchaseTerm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegRepurchaseTerm" "', argument " "1"" of type '" "FIX::LegRepurchaseTerm *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegRepurchaseTerm * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RegistAcctType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistAcctType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RegistAcctType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistAcctType *)new FIX::RegistAcctType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistAcctType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistAcctType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RegistAcctType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RegistAcctType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegistAcctType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegistAcctType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistAcctType *)new FIX::RegistAcctType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistAcctType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistAcctType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RegistAcctType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistAcctType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RegistAcctType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RegistAcctType::RegistAcctType()\n"
    "    FIX::RegistAcctType::RegistAcctType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RegistAcctType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistAcctType *arg1 = (FIX::RegistAcctType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RegistAcctType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RegistAcctType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegistAcctType" "', argument " "1"" of type '" "FIX::RegistAcctType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RegistAcctType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MassActionRejectReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassActionRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MassActionRejectReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassActionRejectReason *)new FIX::MassActionRejectReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassActionRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MassActionRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MassActionRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassActionRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassActionRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassActionRejectReason *)new FIX::MassActionRejectReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassActionRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MassActionRejectReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassActionRejectReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MassActionRejectReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MassActionRejectReason::MassActionRejectReason()\n"
    "    FIX::MassActionRejectReason::MassActionRejectReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MassActionRejectReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassActionRejectReason *arg1 = (FIX::MassActionRejectReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MassActionRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MassActionRejectReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MassActionRejectReason" "', argument " "1"" of type '" "FIX::MassActionRejectReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MassActionRejectReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativePutOrCall__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativePutOrCall *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativePutOrCall")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativePutOrCall *)new FIX::DerivativePutOrCall();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativePutOrCall, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePutOrCall__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativePutOrCall *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativePutOrCall",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativePutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativePutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativePutOrCall *)new FIX::DerivativePutOrCall((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativePutOrCall, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePutOrCall(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativePutOrCall__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativePutOrCall__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativePutOrCall'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativePutOrCall::DerivativePutOrCall()\n"
    "    FIX::DerivativePutOrCall::DerivativePutOrCall(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativePutOrCall(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativePutOrCall *arg1 = (FIX::DerivativePutOrCall *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativePutOrCall",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativePutOrCall, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativePutOrCall" "', argument " "1"" of type '" "FIX::DerivativePutOrCall *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativePutOrCall * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StartMaturityMonthYear__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StartMaturityMonthYear *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StartMaturityMonthYear")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StartMaturityMonthYear *)new FIX::StartMaturityMonthYear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StartMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartMaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StartMaturityMonthYear *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StartMaturityMonthYear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StartMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StartMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StartMaturityMonthYear *)new FIX::StartMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StartMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartMaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StartMaturityMonthYear__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StartMaturityMonthYear__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StartMaturityMonthYear'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StartMaturityMonthYear::StartMaturityMonthYear()\n"
    "    FIX::StartMaturityMonthYear::StartMaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StartMaturityMonthYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StartMaturityMonthYear *arg1 = (FIX::StartMaturityMonthYear *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StartMaturityMonthYear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StartMaturityMonthYear, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StartMaturityMonthYear" "', argument " "1"" of type '" "FIX::StartMaturityMonthYear *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StartMaturityMonthYear * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CollApplType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollApplType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollApplType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollApplType *)new FIX::CollApplType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollApplType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollApplType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollApplType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollApplType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollApplType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollApplType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollApplType *)new FIX::CollApplType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollApplType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollApplType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollApplType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollApplType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollApplType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollApplType::CollApplType()\n"
    "    FIX::CollApplType::CollApplType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollApplType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollApplType *arg1 = (FIX::CollApplType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollApplType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollApplType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollApplType" "', argument " "1"" of type '" "FIX::CollApplType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollApplType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoUnderlyingAmounts__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoUnderlyingAmounts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoUnderlyingAmounts")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoUnderlyingAmounts *)new FIX::NoUnderlyingAmounts();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoUnderlyingAmounts, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingAmounts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoUnderlyingAmounts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoUnderlyingAmounts",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoUnderlyingAmounts" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoUnderlyingAmounts" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoUnderlyingAmounts *)new FIX::NoUnderlyingAmounts((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoUnderlyingAmounts, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingAmounts(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoUnderlyingAmounts__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoUnderlyingAmounts__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoUnderlyingAmounts'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoUnderlyingAmounts::NoUnderlyingAmounts()\n"
    "    FIX::NoUnderlyingAmounts::NoUnderlyingAmounts(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoUnderlyingAmounts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoUnderlyingAmounts *arg1 = (FIX::NoUnderlyingAmounts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoUnderlyingAmounts",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoUnderlyingAmounts, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoUnderlyingAmounts" "', argument " "1"" of type '" "FIX::NoUnderlyingAmounts *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoUnderlyingAmounts * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ConfirmType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfirmType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ConfirmType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfirmType *)new FIX::ConfirmType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfirmType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ConfirmType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ConfirmType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfirmType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConfirmType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfirmType *)new FIX::ConfirmType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfirmType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ConfirmType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfirmType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ConfirmType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ConfirmType::ConfirmType()\n"
    "    FIX::ConfirmType::ConfirmType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConfirmType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfirmType *arg1 = (FIX::ConfirmType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ConfirmType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ConfirmType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfirmType" "', argument " "1"" of type '" "FIX::ConfirmType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ConfirmType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegMaturityMonthYear__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegMaturityMonthYear *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegMaturityMonthYear")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegMaturityMonthYear *)new FIX::LegMaturityMonthYear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegMaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegMaturityMonthYear *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegMaturityMonthYear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegMaturityMonthYear *)new FIX::LegMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegMaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegMaturityMonthYear__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegMaturityMonthYear__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegMaturityMonthYear'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegMaturityMonthYear::LegMaturityMonthYear()\n"
    "    FIX::LegMaturityMonthYear::LegMaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegMaturityMonthYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegMaturityMonthYear *arg1 = (FIX::LegMaturityMonthYear *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegMaturityMonthYear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegMaturityMonthYear, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegMaturityMonthYear" "', argument " "1"" of type '" "FIX::LegMaturityMonthYear *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegMaturityMonthYear * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RelatdSym__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatdSym *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RelatdSym")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatdSym *)new FIX::RelatdSym();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatdSym, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelatdSym__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RelatdSym *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RelatdSym",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RelatdSym" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RelatdSym" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RelatdSym *)new FIX::RelatdSym((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RelatdSym, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RelatdSym(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RelatdSym__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RelatdSym__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RelatdSym'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RelatdSym::RelatdSym()\n"
    "    FIX::RelatdSym::RelatdSym(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RelatdSym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RelatdSym *arg1 = (FIX::RelatdSym *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RelatdSym",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RelatdSym, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RelatdSym" "', argument " "1"" of type '" "FIX::RelatdSym *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RelatdSym * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecuritySubType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecuritySubType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegSecuritySubType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecuritySubType *)new FIX::UnderlyingLegSecuritySubType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecuritySubType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecuritySubType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegSecuritySubType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegSecuritySubType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecuritySubType *)new FIX::UnderlyingLegSecuritySubType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecuritySubType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecuritySubType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegSecuritySubType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecuritySubType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegSecuritySubType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegSecuritySubType::UnderlyingLegSecuritySubType()\n"
    "    FIX::UnderlyingLegSecuritySubType::UnderlyingLegSecuritySubType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegSecuritySubType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecuritySubType *arg1 = (FIX::UnderlyingLegSecuritySubType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegSecuritySubType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegSecuritySubType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegSecuritySubType" "', argument " "1"" of type '" "FIX::UnderlyingLegSecuritySubType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegSecuritySubType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoUnderlyingSecurityAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoUnderlyingSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoUnderlyingSecurityAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoUnderlyingSecurityAltID *)new FIX::NoUnderlyingSecurityAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoUnderlyingSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoUnderlyingSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoUnderlyingSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoUnderlyingSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoUnderlyingSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoUnderlyingSecurityAltID *)new FIX::NoUnderlyingSecurityAltID((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoUnderlyingSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoUnderlyingSecurityAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoUnderlyingSecurityAltID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoUnderlyingSecurityAltID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoUnderlyingSecurityAltID::NoUnderlyingSecurityAltID()\n"
    "    FIX::NoUnderlyingSecurityAltID::NoUnderlyingSecurityAltID(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoUnderlyingSecurityAltID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoUnderlyingSecurityAltID *arg1 = (FIX::NoUnderlyingSecurityAltID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoUnderlyingSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoUnderlyingSecurityAltID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoUnderlyingSecurityAltID" "', argument " "1"" of type '" "FIX::NoUnderlyingSecurityAltID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoUnderlyingSecurityAltID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDQuoteType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDQuoteType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDQuoteType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDQuoteType *)new FIX::MDQuoteType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDQuoteType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDQuoteType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDQuoteType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDQuoteType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDQuoteType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDQuoteType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDQuoteType *)new FIX::MDQuoteType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDQuoteType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDQuoteType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDQuoteType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDQuoteType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDQuoteType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDQuoteType::MDQuoteType()\n"
    "    FIX::MDQuoteType::MDQuoteType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDQuoteType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDQuoteType *arg1 = (FIX::MDQuoteType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDQuoteType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDQuoteType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDQuoteType" "', argument " "1"" of type '" "FIX::MDQuoteType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDQuoteType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_QtyType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QtyType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QtyType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QtyType *)new FIX::QtyType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QtyType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QtyType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QtyType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QtyType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QtyType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QtyType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QtyType *)new FIX::QtyType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QtyType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QtyType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QtyType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QtyType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QtyType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QtyType::QtyType()\n"
    "    FIX::QtyType::QtyType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QtyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QtyType *arg1 = (FIX::QtyType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QtyType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QtyType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QtyType" "', argument " "1"" of type '" "FIX::QtyType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QtyType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_QuoteRespType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteRespType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteRespType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteRespType *)new FIX::QuoteRespType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteRespType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRespType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteRespType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteRespType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteRespType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteRespType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteRespType *)new FIX::QuoteRespType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteRespType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRespType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteRespType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteRespType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteRespType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteRespType::QuoteRespType()\n"
    "    FIX::QuoteRespType::QuoteRespType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteRespType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteRespType *arg1 = (FIX::QuoteRespType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteRespType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteRespType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteRespType" "', argument " "1"" of type '" "FIX::QuoteRespType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteRespType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_IOINaturalFlag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOINaturalFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IOINaturalFlag")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOINaturalFlag *)new FIX::IOINaturalFlag();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOINaturalFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOINaturalFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IOINaturalFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IOINaturalFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOINaturalFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IOINaturalFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOINaturalFlag *)new FIX::IOINaturalFlag((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOINaturalFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOINaturalFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IOINaturalFlag__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOINaturalFlag__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IOINaturalFlag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IOINaturalFlag::IOINaturalFlag()\n"
    "    FIX::IOINaturalFlag::IOINaturalFlag(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IOINaturalFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOINaturalFlag *arg1 = (FIX::IOINaturalFlag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IOINaturalFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IOINaturalFlag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOINaturalFlag" "', argument " "1"" of type '" "FIX::IOINaturalFlag *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IOINaturalFlag * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BenchmarkCurvePoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BenchmarkCurvePoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BenchmarkCurvePoint")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BenchmarkCurvePoint *)new FIX::BenchmarkCurvePoint();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BenchmarkCurvePoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkCurvePoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BenchmarkCurvePoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BenchmarkCurvePoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BenchmarkCurvePoint" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BenchmarkCurvePoint" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BenchmarkCurvePoint *)new FIX::BenchmarkCurvePoint((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BenchmarkCurvePoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkCurvePoint(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BenchmarkCurvePoint__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BenchmarkCurvePoint__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BenchmarkCurvePoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BenchmarkCurvePoint::BenchmarkCurvePoint()\n"
    "    FIX::BenchmarkCurvePoint::BenchmarkCurvePoint(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BenchmarkCurvePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BenchmarkCurvePoint *arg1 = (FIX::BenchmarkCurvePoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BenchmarkCurvePoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BenchmarkCurvePoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BenchmarkCurvePoint" "', argument " "1"" of type '" "FIX::BenchmarkCurvePoint *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BenchmarkCurvePoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradSesUpdateAction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesUpdateAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradSesUpdateAction")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesUpdateAction *)new FIX::TradSesUpdateAction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesUpdateAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesUpdateAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesUpdateAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesUpdateAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesUpdateAction *)new FIX::TradSesUpdateAction((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesUpdateAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesUpdateAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradSesUpdateAction__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesUpdateAction__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradSesUpdateAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradSesUpdateAction::TradSesUpdateAction()\n"
    "    FIX::TradSesUpdateAction::TradSesUpdateAction(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradSesUpdateAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesUpdateAction *arg1 = (FIX::TradSesUpdateAction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradSesUpdateAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradSesUpdateAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradSesUpdateAction" "', argument " "1"" of type '" "FIX::TradSesUpdateAction *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradSesUpdateAction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingCashAmount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCashAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingCashAmount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCashAmount *)new FIX::UnderlyingCashAmount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCashAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCashAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingCashAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingCashAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingCashAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingCashAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCashAmount *)new FIX::UnderlyingCashAmount((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCashAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCashAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingCashAmount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCashAmount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingCashAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingCashAmount::UnderlyingCashAmount()\n"
    "    FIX::UnderlyingCashAmount::UnderlyingCashAmount(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingCashAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCashAmount *arg1 = (FIX::UnderlyingCashAmount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingCashAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingCashAmount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingCashAmount" "', argument " "1"" of type '" "FIX::UnderlyingCashAmount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingCashAmount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CollAsgnID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollAsgnID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollAsgnID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollAsgnID *)new FIX::CollAsgnID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollAsgnID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollAsgnID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollAsgnID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollAsgnID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollAsgnID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollAsgnID *)new FIX::CollAsgnID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollAsgnID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollAsgnID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollAsgnID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollAsgnID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollAsgnID::CollAsgnID()\n"
    "    FIX::CollAsgnID::CollAsgnID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollAsgnID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollAsgnID *arg1 = (FIX::CollAsgnID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollAsgnID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollAsgnID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollAsgnID" "', argument " "1"" of type '" "FIX::CollAsgnID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollAsgnID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ExchangeRule__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExchangeRule *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExchangeRule")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExchangeRule *)new FIX::ExchangeRule();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExchangeRule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExchangeRule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExchangeRule *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExchangeRule",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExchangeRule" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExchangeRule" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExchangeRule *)new FIX::ExchangeRule((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExchangeRule, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExchangeRule(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExchangeRule__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExchangeRule__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExchangeRule'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExchangeRule::ExchangeRule()\n"
    "    FIX::ExchangeRule::ExchangeRule(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExchangeRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExchangeRule *arg1 = (FIX::ExchangeRule *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExchangeRule",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExchangeRule, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExchangeRule" "', argument " "1"" of type '" "FIX::ExchangeRule *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExchangeRule * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedHeadline__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedHeadline *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedHeadline")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedHeadline *)new FIX::EncodedHeadline();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedHeadline, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedHeadline__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedHeadline *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedHeadline",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedHeadline" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedHeadline" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedHeadline *)new FIX::EncodedHeadline((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedHeadline, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedHeadline(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedHeadline__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedHeadline__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedHeadline'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedHeadline::EncodedHeadline()\n"
    "    FIX::EncodedHeadline::EncodedHeadline(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedHeadline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedHeadline *arg1 = (FIX::EncodedHeadline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedHeadline",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedHeadline, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedHeadline" "', argument " "1"" of type '" "FIX::EncodedHeadline *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedHeadline * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RegistID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RegistID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistID *)new FIX::RegistID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RegistID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RegistID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegistID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegistID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistID *)new FIX::RegistID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RegistID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RegistID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RegistID::RegistID()\n"
    "    FIX::RegistID::RegistID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RegistID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistID *arg1 = (FIX::RegistID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RegistID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RegistID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegistID" "', argument " "1"" of type '" "FIX::RegistID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RegistID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CrossID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CrossID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CrossID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CrossID *)new FIX::CrossID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CrossID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CrossID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CrossID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CrossID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CrossID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CrossID *)new FIX::CrossID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CrossID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CrossID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CrossID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CrossID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CrossID::CrossID()\n"
    "    FIX::CrossID::CrossID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CrossID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CrossID *arg1 = (FIX::CrossID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CrossID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CrossID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CrossID" "', argument " "1"" of type '" "FIX::CrossID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CrossID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoExecs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoExecs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoExecs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoExecs *)new FIX::NoExecs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoExecs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoExecs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoExecs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoExecs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoExecs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoExecs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoExecs *)new FIX::NoExecs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoExecs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoExecs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoExecs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoExecs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoExecs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoExecs::NoExecs()\n"
    "    FIX::NoExecs::NoExecs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoExecs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoExecs *arg1 = (FIX::NoExecs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoExecs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoExecs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoExecs" "', argument " "1"" of type '" "FIX::NoExecs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoExecs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeSecurityGroup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityGroup *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSecurityGroup")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityGroup *)new FIX::DerivativeSecurityGroup();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityGroup, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityGroup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSecurityGroup *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSecurityGroup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSecurityGroup" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSecurityGroup" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityGroup *)new FIX::DerivativeSecurityGroup((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityGroup, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSecurityGroup__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityGroup__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSecurityGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSecurityGroup::DerivativeSecurityGroup()\n"
    "    FIX::DerivativeSecurityGroup::DerivativeSecurityGroup(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSecurityGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityGroup *arg1 = (FIX::DerivativeSecurityGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSecurityGroup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSecurityGroup, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSecurityGroup" "', argument " "1"" of type '" "FIX::DerivativeSecurityGroup *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSecurityGroup * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecondaryDisplayQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryDisplayQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryDisplayQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryDisplayQty *)new FIX::SecondaryDisplayQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryDisplayQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryDisplayQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryDisplayQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryDisplayQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryDisplayQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryDisplayQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryDisplayQty *)new FIX::SecondaryDisplayQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryDisplayQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryDisplayQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryDisplayQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryDisplayQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryDisplayQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryDisplayQty::SecondaryDisplayQty()\n"
    "    FIX::SecondaryDisplayQty::SecondaryDisplayQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryDisplayQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryDisplayQty *arg1 = (FIX::SecondaryDisplayQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryDisplayQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryDisplayQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryDisplayQty" "', argument " "1"" of type '" "FIX::SecondaryDisplayQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryDisplayQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RefMsgType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefMsgType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefMsgType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefMsgType *)new FIX::RefMsgType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefMsgType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefMsgType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefMsgType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefMsgType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefMsgType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefMsgType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefMsgType *)new FIX::RefMsgType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefMsgType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefMsgType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefMsgType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefMsgType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefMsgType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefMsgType::RefMsgType()\n"
    "    FIX::RefMsgType::RefMsgType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefMsgType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefMsgType *arg1 = (FIX::RefMsgType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefMsgType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefMsgType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefMsgType" "', argument " "1"" of type '" "FIX::RefMsgType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefMsgType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StandInstDbID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StandInstDbID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StandInstDbID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StandInstDbID *)new FIX::StandInstDbID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StandInstDbID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StandInstDbID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StandInstDbID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StandInstDbID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StandInstDbID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StandInstDbID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StandInstDbID *)new FIX::StandInstDbID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StandInstDbID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StandInstDbID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StandInstDbID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StandInstDbID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StandInstDbID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StandInstDbID::StandInstDbID()\n"
    "    FIX::StandInstDbID::StandInstDbID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StandInstDbID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StandInstDbID *arg1 = (FIX::StandInstDbID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StandInstDbID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StandInstDbID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StandInstDbID" "', argument " "1"" of type '" "FIX::StandInstDbID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StandInstDbID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedLegSecurityDescLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedLegSecurityDescLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedLegSecurityDescLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedLegSecurityDescLen *)new FIX::EncodedLegSecurityDescLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedLegSecurityDescLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegSecurityDescLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedLegSecurityDescLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedLegSecurityDescLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedLegSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedLegSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedLegSecurityDescLen *)new FIX::EncodedLegSecurityDescLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedLegSecurityDescLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegSecurityDescLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedLegSecurityDescLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedLegSecurityDescLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedLegSecurityDescLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedLegSecurityDescLen::EncodedLegSecurityDescLen()\n"
    "    FIX::EncodedLegSecurityDescLen::EncodedLegSecurityDescLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedLegSecurityDescLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedLegSecurityDescLen *arg1 = (FIX::EncodedLegSecurityDescLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedLegSecurityDescLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedLegSecurityDescLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedLegSecurityDescLen" "', argument " "1"" of type '" "FIX::EncodedLegSecurityDescLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedLegSecurityDescLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeEventPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEventPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeEventPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEventPx *)new FIX::DerivativeEventPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEventPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeEventPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeEventPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeEventPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeEventPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEventPx *)new FIX::DerivativeEventPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEventPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEventPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeEventPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEventPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeEventPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeEventPx::DerivativeEventPx()\n"
    "    FIX::DerivativeEventPx::DerivativeEventPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeEventPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEventPx *arg1 = (FIX::DerivativeEventPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeEventPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeEventPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeEventPx" "', argument " "1"" of type '" "FIX::DerivativeEventPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeEventPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlObligSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlObligSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlObligSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlObligSource *)new FIX::SettlObligSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlObligSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlObligSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlObligSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlObligSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlObligSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlObligSource *)new FIX::SettlObligSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlObligSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlObligSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlObligSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlObligSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlObligSource::SettlObligSource()\n"
    "    FIX::SettlObligSource::SettlObligSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlObligSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlObligSource *arg1 = (FIX::SettlObligSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlObligSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlObligSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlObligSource" "', argument " "1"" of type '" "FIX::SettlObligSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlObligSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TrdSubType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdSubType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TrdSubType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdSubType *)new FIX::TrdSubType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdSubType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdSubType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TrdSubType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TrdSubType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrdSubType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TrdSubType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdSubType *)new FIX::TrdSubType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdSubType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdSubType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TrdSubType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdSubType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TrdSubType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TrdSubType::TrdSubType()\n"
    "    FIX::TrdSubType::TrdSubType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TrdSubType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdSubType *arg1 = (FIX::TrdSubType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TrdSubType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TrdSubType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrdSubType" "', argument " "1"" of type '" "FIX::TrdSubType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TrdSubType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingIssuerLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedUnderlyingIssuerLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedUnderlyingIssuerLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedUnderlyingIssuerLen *)new FIX::EncodedUnderlyingIssuerLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedUnderlyingIssuerLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingIssuerLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedUnderlyingIssuerLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedUnderlyingIssuerLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedUnderlyingIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedUnderlyingIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedUnderlyingIssuerLen *)new FIX::EncodedUnderlyingIssuerLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedUnderlyingIssuerLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingIssuerLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedUnderlyingIssuerLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedUnderlyingIssuerLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedUnderlyingIssuerLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedUnderlyingIssuerLen::EncodedUnderlyingIssuerLen()\n"
    "    FIX::EncodedUnderlyingIssuerLen::EncodedUnderlyingIssuerLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedUnderlyingIssuerLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedUnderlyingIssuerLen *arg1 = (FIX::EncodedUnderlyingIssuerLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedUnderlyingIssuerLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedUnderlyingIssuerLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedUnderlyingIssuerLen" "', argument " "1"" of type '" "FIX::EncodedUnderlyingIssuerLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedUnderlyingIssuerLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ExecTransType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExecTransType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecTransType *)new FIX::ExecTransType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExecTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExecTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExecTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExecTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecTransType *)new FIX::ExecTransType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExecTransType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecTransType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExecTransType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExecTransType::ExecTransType()\n"
    "    FIX::ExecTransType::ExecTransType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExecTransType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecTransType *arg1 = (FIX::ExecTransType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExecTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExecTransType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExecTransType" "', argument " "1"" of type '" "FIX::ExecTransType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExecTransType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_BeginSeqNo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BeginSeqNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BeginSeqNo")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BeginSeqNo *)new FIX::BeginSeqNo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BeginSeqNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BeginSeqNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BeginSeqNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BeginSeqNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SEQNUM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BeginSeqNo" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BeginSeqNo" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BeginSeqNo *)new FIX::BeginSeqNo((FIX::SEQNUM const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BeginSeqNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BeginSeqNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BeginSeqNo__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BeginSeqNo__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BeginSeqNo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BeginSeqNo::BeginSeqNo()\n"
    "    FIX::BeginSeqNo::BeginSeqNo(FIX::SEQNUM const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BeginSeqNo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BeginSeqNo *arg1 = (FIX::BeginSeqNo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BeginSeqNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BeginSeqNo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BeginSeqNo" "', argument " "1"" of type '" "FIX::BeginSeqNo *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BeginSeqNo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DayBookingInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DayBookingInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DayBookingInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DayBookingInst *)new FIX::DayBookingInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DayBookingInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayBookingInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DayBookingInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DayBookingInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DayBookingInst" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DayBookingInst" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DayBookingInst *)new FIX::DayBookingInst((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DayBookingInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DayBookingInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DayBookingInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DayBookingInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DayBookingInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DayBookingInst::DayBookingInst()\n"
    "    FIX::DayBookingInst::DayBookingInst(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DayBookingInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DayBookingInst *arg1 = (FIX::DayBookingInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DayBookingInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DayBookingInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DayBookingInst" "', argument " "1"" of type '" "FIX::DayBookingInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DayBookingInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FlowScheduleType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FlowScheduleType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FlowScheduleType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FlowScheduleType *)new FIX::FlowScheduleType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FlowScheduleType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlowScheduleType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FlowScheduleType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FlowScheduleType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FlowScheduleType *)new FIX::FlowScheduleType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FlowScheduleType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlowScheduleType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FlowScheduleType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FlowScheduleType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FlowScheduleType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FlowScheduleType::FlowScheduleType()\n"
    "    FIX::FlowScheduleType::FlowScheduleType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FlowScheduleType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FlowScheduleType *arg1 = (FIX::FlowScheduleType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FlowScheduleType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FlowScheduleType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FlowScheduleType" "', argument " "1"" of type '" "FIX::FlowScheduleType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FlowScheduleType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDOriginType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDOriginType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDOriginType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDOriginType *)new FIX::MDOriginType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDOriginType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDOriginType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDOriginType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDOriginType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDOriginType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDOriginType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDOriginType *)new FIX::MDOriginType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDOriginType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDOriginType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDOriginType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDOriginType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDOriginType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDOriginType::MDOriginType()\n"
    "    FIX::MDOriginType::MDOriginType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDOriginType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDOriginType *arg1 = (FIX::MDOriginType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDOriginType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDOriginType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDOriginType" "', argument " "1"" of type '" "FIX::MDOriginType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDOriginType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CollInquiryStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollInquiryStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollInquiryStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollInquiryStatus *)new FIX::CollInquiryStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollInquiryStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollInquiryStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollInquiryStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollInquiryStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollInquiryStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollInquiryStatus *)new FIX::CollInquiryStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollInquiryStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollInquiryStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollInquiryStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollInquiryStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollInquiryStatus::CollInquiryStatus()\n"
    "    FIX::CollInquiryStatus::CollInquiryStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollInquiryStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollInquiryStatus *arg1 = (FIX::CollInquiryStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollInquiryStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollInquiryStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollInquiryStatus" "', argument " "1"" of type '" "FIX::CollInquiryStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollInquiryStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoInstrAttrib__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoInstrAttrib *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoInstrAttrib")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoInstrAttrib *)new FIX::NoInstrAttrib();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoInstrAttrib, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoInstrAttrib__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoInstrAttrib *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoInstrAttrib",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoInstrAttrib" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoInstrAttrib" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoInstrAttrib *)new FIX::NoInstrAttrib((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoInstrAttrib, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoInstrAttrib(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoInstrAttrib__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoInstrAttrib__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoInstrAttrib'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoInstrAttrib::NoInstrAttrib()\n"
    "    FIX::NoInstrAttrib::NoInstrAttrib(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoInstrAttrib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoInstrAttrib *arg1 = (FIX::NoInstrAttrib *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoInstrAttrib",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoInstrAttrib, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoInstrAttrib" "', argument " "1"" of type '" "FIX::NoInstrAttrib *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoInstrAttrib * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RegistEmail__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistEmail *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RegistEmail")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistEmail *)new FIX::RegistEmail();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistEmail, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistEmail__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RegistEmail *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RegistEmail",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegistEmail" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegistEmail" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistEmail *)new FIX::RegistEmail((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistEmail, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistEmail(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RegistEmail__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistEmail__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RegistEmail'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RegistEmail::RegistEmail()\n"
    "    FIX::RegistEmail::RegistEmail(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RegistEmail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistEmail *arg1 = (FIX::RegistEmail *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RegistEmail",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RegistEmail, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegistEmail" "', argument " "1"" of type '" "FIX::RegistEmail *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RegistEmail * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StreamAsgnReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StreamAsgnReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StreamAsgnReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StreamAsgnReqID *)new FIX::StreamAsgnReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StreamAsgnReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StreamAsgnReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StreamAsgnReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StreamAsgnReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StreamAsgnReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StreamAsgnReqID *)new FIX::StreamAsgnReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StreamAsgnReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StreamAsgnReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StreamAsgnReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StreamAsgnReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StreamAsgnReqID::StreamAsgnReqID()\n"
    "    FIX::StreamAsgnReqID::StreamAsgnReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StreamAsgnReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StreamAsgnReqID *arg1 = (FIX::StreamAsgnReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StreamAsgnReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StreamAsgnReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StreamAsgnReqID" "', argument " "1"" of type '" "FIX::StreamAsgnReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StreamAsgnReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CPProgram__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CPProgram *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CPProgram")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CPProgram *)new FIX::CPProgram();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CPProgram, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPProgram__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CPProgram *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CPProgram",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CPProgram" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CPProgram" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CPProgram *)new FIX::CPProgram((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CPProgram, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CPProgram(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CPProgram__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CPProgram__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CPProgram'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CPProgram::CPProgram()\n"
    "    FIX::CPProgram::CPProgram(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CPProgram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CPProgram *arg1 = (FIX::CPProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CPProgram",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CPProgram, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPProgram" "', argument " "1"" of type '" "FIX::CPProgram *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CPProgram * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ConfirmReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfirmReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ConfirmReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfirmReqID *)new FIX::ConfirmReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfirmReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ConfirmReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ConfirmReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfirmReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConfirmReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfirmReqID *)new FIX::ConfirmReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfirmReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ConfirmReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfirmReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ConfirmReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ConfirmReqID::ConfirmReqID()\n"
    "    FIX::ConfirmReqID::ConfirmReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConfirmReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfirmReqID *arg1 = (FIX::ConfirmReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ConfirmReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ConfirmReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfirmReqID" "', argument " "1"" of type '" "FIX::ConfirmReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ConfirmReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AltMDSourceID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AltMDSourceID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AltMDSourceID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AltMDSourceID *)new FIX::AltMDSourceID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AltMDSourceID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AltMDSourceID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AltMDSourceID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AltMDSourceID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AltMDSourceID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AltMDSourceID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AltMDSourceID *)new FIX::AltMDSourceID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AltMDSourceID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AltMDSourceID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AltMDSourceID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AltMDSourceID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AltMDSourceID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AltMDSourceID::AltMDSourceID()\n"
    "    FIX::AltMDSourceID::AltMDSourceID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AltMDSourceID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AltMDSourceID *arg1 = (FIX::AltMDSourceID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AltMDSourceID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AltMDSourceID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AltMDSourceID" "', argument " "1"" of type '" "FIX::AltMDSourceID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AltMDSourceID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoOrders__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoOrders *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoOrders")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoOrders *)new FIX::NoOrders();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoOrders, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOrders__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoOrders *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoOrders",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoOrders" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoOrders" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoOrders *)new FIX::NoOrders((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoOrders, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOrders(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoOrders__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoOrders__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoOrders'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoOrders::NoOrders()\n"
    "    FIX::NoOrders::NoOrders(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoOrders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoOrders *arg1 = (FIX::NoOrders *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoOrders",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoOrders, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoOrders" "', argument " "1"" of type '" "FIX::NoOrders *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoOrders * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CashDistribAgentAcctName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashDistribAgentAcctName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashDistribAgentAcctName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashDistribAgentAcctName *)new FIX::CashDistribAgentAcctName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashDistribAgentAcctName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentAcctName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashDistribAgentAcctName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashDistribAgentAcctName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashDistribAgentAcctName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashDistribAgentAcctName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashDistribAgentAcctName *)new FIX::CashDistribAgentAcctName((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashDistribAgentAcctName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribAgentAcctName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashDistribAgentAcctName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashDistribAgentAcctName__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashDistribAgentAcctName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashDistribAgentAcctName::CashDistribAgentAcctName()\n"
    "    FIX::CashDistribAgentAcctName::CashDistribAgentAcctName(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashDistribAgentAcctName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashDistribAgentAcctName *arg1 = (FIX::CashDistribAgentAcctName *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashDistribAgentAcctName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashDistribAgentAcctName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashDistribAgentAcctName" "', argument " "1"" of type '" "FIX::CashDistribAgentAcctName *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashDistribAgentAcctName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UndlyInstrumentPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UndlyInstrumentPartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UndlyInstrumentPartyIDSource *)new FIX::UndlyInstrumentPartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UndlyInstrumentPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UndlyInstrumentPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UndlyInstrumentPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UndlyInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UndlyInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UndlyInstrumentPartyIDSource *)new FIX::UndlyInstrumentPartyIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UndlyInstrumentPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UndlyInstrumentPartyIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UndlyInstrumentPartyIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UndlyInstrumentPartyIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UndlyInstrumentPartyIDSource::UndlyInstrumentPartyIDSource()\n"
    "    FIX::UndlyInstrumentPartyIDSource::UndlyInstrumentPartyIDSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UndlyInstrumentPartyIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UndlyInstrumentPartyIDSource *arg1 = (FIX::UndlyInstrumentPartyIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UndlyInstrumentPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UndlyInstrumentPartyIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UndlyInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::UndlyInstrumentPartyIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UndlyInstrumentPartyIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingSettlMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSettlMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSettlMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSettlMethod *)new FIX::UnderlyingSettlMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSettlMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSettlMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSettlMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSettlMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSettlMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSettlMethod *)new FIX::UnderlyingSettlMethod((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSettlMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSettlMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSettlMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSettlMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSettlMethod::UnderlyingSettlMethod()\n"
    "    FIX::UnderlyingSettlMethod::UnderlyingSettlMethod(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSettlMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSettlMethod *arg1 = (FIX::UnderlyingSettlMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSettlMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSettlMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSettlMethod" "', argument " "1"" of type '" "FIX::UnderlyingSettlMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSettlMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoMDEntryTypes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMDEntryTypes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoMDEntryTypes")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMDEntryTypes *)new FIX::NoMDEntryTypes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMDEntryTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMDEntryTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoMDEntryTypes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoMDEntryTypes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoMDEntryTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoMDEntryTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMDEntryTypes *)new FIX::NoMDEntryTypes((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMDEntryTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMDEntryTypes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoMDEntryTypes__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMDEntryTypes__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoMDEntryTypes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoMDEntryTypes::NoMDEntryTypes()\n"
    "    FIX::NoMDEntryTypes::NoMDEntryTypes(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoMDEntryTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMDEntryTypes *arg1 = (FIX::NoMDEntryTypes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoMDEntryTypes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoMDEntryTypes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoMDEntryTypes" "', argument " "1"" of type '" "FIX::NoMDEntryTypes *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoMDEntryTypes * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDEntryForwardPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryForwardPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDEntryForwardPoints")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryForwardPoints *)new FIX::MDEntryForwardPoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryForwardPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryForwardPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDEntryForwardPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDEntryForwardPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDEntryForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDEntryForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryForwardPoints *)new FIX::MDEntryForwardPoints((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryForwardPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryForwardPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDEntryForwardPoints__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryForwardPoints__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDEntryForwardPoints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDEntryForwardPoints::MDEntryForwardPoints()\n"
    "    FIX::MDEntryForwardPoints::MDEntryForwardPoints(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDEntryForwardPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryForwardPoints *arg1 = (FIX::MDEntryForwardPoints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDEntryForwardPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDEntryForwardPoints, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDEntryForwardPoints" "', argument " "1"" of type '" "FIX::MDEntryForwardPoints *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDEntryForwardPoints * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PosReqType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosReqType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PosReqType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosReqType *)new FIX::PosReqType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosReqType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PosReqType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PosReqType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PosReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PosReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosReqType *)new FIX::PosReqType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosReqType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PosReqType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosReqType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PosReqType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PosReqType::PosReqType()\n"
    "    FIX::PosReqType::PosReqType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PosReqType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosReqType *arg1 = (FIX::PosReqType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PosReqType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PosReqType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PosReqType" "', argument " "1"" of type '" "FIX::PosReqType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PosReqType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MassStatusReqType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassStatusReqType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MassStatusReqType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassStatusReqType *)new FIX::MassStatusReqType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassStatusReqType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassStatusReqType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MassStatusReqType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MassStatusReqType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassStatusReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassStatusReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassStatusReqType *)new FIX::MassStatusReqType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassStatusReqType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassStatusReqType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MassStatusReqType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassStatusReqType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MassStatusReqType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MassStatusReqType::MassStatusReqType()\n"
    "    FIX::MassStatusReqType::MassStatusReqType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MassStatusReqType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassStatusReqType *arg1 = (FIX::MassStatusReqType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MassStatusReqType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MassStatusReqType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MassStatusReqType" "', argument " "1"" of type '" "FIX::MassStatusReqType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MassStatusReqType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradeOriginationDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeOriginationDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeOriginationDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeOriginationDate *)new FIX::TradeOriginationDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeOriginationDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeOriginationDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeOriginationDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeOriginationDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeOriginationDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeOriginationDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeOriginationDate *)new FIX::TradeOriginationDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeOriginationDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeOriginationDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeOriginationDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeOriginationDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeOriginationDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeOriginationDate::TradeOriginationDate()\n"
    "    FIX::TradeOriginationDate::TradeOriginationDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeOriginationDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeOriginationDate *arg1 = (FIX::TradeOriginationDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeOriginationDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeOriginationDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeOriginationDate" "', argument " "1"" of type '" "FIX::TradeOriginationDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeOriginationDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlPrice *)new FIX::SettlPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlPrice *)new FIX::SettlPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlPrice::SettlPrice()\n"
    "    FIX::SettlPrice::SettlPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlPrice *arg1 = (FIX::SettlPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlPrice" "', argument " "1"" of type '" "FIX::SettlPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentAcctName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecuritySettlAgentAcctName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecuritySettlAgentAcctName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecuritySettlAgentAcctName *)new FIX::SecuritySettlAgentAcctName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecuritySettlAgentAcctName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentAcctName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecuritySettlAgentAcctName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecuritySettlAgentAcctName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecuritySettlAgentAcctName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecuritySettlAgentAcctName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecuritySettlAgentAcctName *)new FIX::SecuritySettlAgentAcctName((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecuritySettlAgentAcctName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentAcctName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecuritySettlAgentAcctName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecuritySettlAgentAcctName__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecuritySettlAgentAcctName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecuritySettlAgentAcctName::SecuritySettlAgentAcctName()\n"
    "    FIX::SecuritySettlAgentAcctName::SecuritySettlAgentAcctName(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecuritySettlAgentAcctName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecuritySettlAgentAcctName *arg1 = (FIX::SecuritySettlAgentAcctName *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecuritySettlAgentAcctName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecuritySettlAgentAcctName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecuritySettlAgentAcctName" "', argument " "1"" of type '" "FIX::SecuritySettlAgentAcctName *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecuritySettlAgentAcctName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoDerivativeEvents__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDerivativeEvents *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoDerivativeEvents")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDerivativeEvents *)new FIX::NoDerivativeEvents();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDerivativeEvents, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeEvents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoDerivativeEvents *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoDerivativeEvents",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoDerivativeEvents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoDerivativeEvents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDerivativeEvents *)new FIX::NoDerivativeEvents((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDerivativeEvents, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeEvents(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoDerivativeEvents__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDerivativeEvents__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoDerivativeEvents'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoDerivativeEvents::NoDerivativeEvents()\n"
    "    FIX::NoDerivativeEvents::NoDerivativeEvents(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoDerivativeEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDerivativeEvents *arg1 = (FIX::NoDerivativeEvents *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoDerivativeEvents",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoDerivativeEvents, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoDerivativeEvents" "', argument " "1"" of type '" "FIX::NoDerivativeEvents *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoDerivativeEvents * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingEndPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingEndPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingEndPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingEndPrice *)new FIX::UnderlyingEndPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingEndPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingEndPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingEndPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingEndPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingEndPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingEndPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingEndPrice *)new FIX::UnderlyingEndPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingEndPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingEndPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingEndPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingEndPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingEndPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingEndPrice::UnderlyingEndPrice()\n"
    "    FIX::UnderlyingEndPrice::UnderlyingEndPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingEndPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingEndPrice *arg1 = (FIX::UnderlyingEndPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingEndPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingEndPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingEndPrice" "', argument " "1"" of type '" "FIX::UnderlyingEndPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingEndPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SubscriptionRequestType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SubscriptionRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SubscriptionRequestType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SubscriptionRequestType *)new FIX::SubscriptionRequestType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SubscriptionRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SubscriptionRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SubscriptionRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SubscriptionRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SubscriptionRequestType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SubscriptionRequestType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SubscriptionRequestType *)new FIX::SubscriptionRequestType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SubscriptionRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SubscriptionRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SubscriptionRequestType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SubscriptionRequestType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SubscriptionRequestType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SubscriptionRequestType::SubscriptionRequestType()\n"
    "    FIX::SubscriptionRequestType::SubscriptionRequestType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SubscriptionRequestType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SubscriptionRequestType *arg1 = (FIX::SubscriptionRequestType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SubscriptionRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SubscriptionRequestType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SubscriptionRequestType" "', argument " "1"" of type '" "FIX::SubscriptionRequestType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SubscriptionRequestType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TotalNumSecurityTypes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalNumSecurityTypes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotalNumSecurityTypes")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalNumSecurityTypes *)new FIX::TotalNumSecurityTypes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalNumSecurityTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNumSecurityTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotalNumSecurityTypes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotalNumSecurityTypes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotalNumSecurityTypes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotalNumSecurityTypes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalNumSecurityTypes *)new FIX::TotalNumSecurityTypes((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalNumSecurityTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNumSecurityTypes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotalNumSecurityTypes__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalNumSecurityTypes__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotalNumSecurityTypes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotalNumSecurityTypes::TotalNumSecurityTypes()\n"
    "    FIX::TotalNumSecurityTypes::TotalNumSecurityTypes(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotalNumSecurityTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalNumSecurityTypes *arg1 = (FIX::TotalNumSecurityTypes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotalNumSecurityTypes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotalNumSecurityTypes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotalNumSecurityTypes" "', argument " "1"" of type '" "FIX::TotalNumSecurityTypes *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotalNumSecurityTypes * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NewsCategory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NewsCategory *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NewsCategory")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NewsCategory *)new FIX::NewsCategory();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NewsCategory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsCategory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NewsCategory *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NewsCategory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewsCategory" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NewsCategory" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NewsCategory *)new FIX::NewsCategory((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NewsCategory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsCategory(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NewsCategory__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NewsCategory__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NewsCategory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NewsCategory::NewsCategory()\n"
    "    FIX::NewsCategory::NewsCategory(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NewsCategory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NewsCategory *arg1 = (FIX::NewsCategory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NewsCategory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NewsCategory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewsCategory" "', argument " "1"" of type '" "FIX::NewsCategory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NewsCategory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingLegPutOrCall__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegPutOrCall *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegPutOrCall")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegPutOrCall *)new FIX::UnderlyingLegPutOrCall();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegPutOrCall, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegPutOrCall__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegPutOrCall *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegPutOrCall",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegPutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegPutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegPutOrCall *)new FIX::UnderlyingLegPutOrCall((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegPutOrCall, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegPutOrCall(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegPutOrCall__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegPutOrCall__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegPutOrCall'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegPutOrCall::UnderlyingLegPutOrCall()\n"
    "    FIX::UnderlyingLegPutOrCall::UnderlyingLegPutOrCall(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegPutOrCall(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegPutOrCall *arg1 = (FIX::UnderlyingLegPutOrCall *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegPutOrCall",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegPutOrCall, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegPutOrCall" "', argument " "1"" of type '" "FIX::UnderlyingLegPutOrCall *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegPutOrCall * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_URLLink__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::URLLink *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_URLLink")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::URLLink *)new FIX::URLLink();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__URLLink, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_URLLink__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::URLLink *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_URLLink",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_URLLink" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_URLLink" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::URLLink *)new FIX::URLLink((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__URLLink, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_URLLink(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_URLLink__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_URLLink__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_URLLink'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::URLLink::URLLink()\n"
    "    FIX::URLLink::URLLink(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_URLLink(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::URLLink *arg1 = (FIX::URLLink *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_URLLink",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__URLLink, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_URLLink" "', argument " "1"" of type '" "FIX::URLLink *""'"); 
  }
  arg1 = reinterpret_cast< FIX::URLLink * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoInstrumentPartySubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoInstrumentPartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoInstrumentPartySubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoInstrumentPartySubIDs *)new FIX::NoInstrumentPartySubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoInstrumentPartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoInstrumentPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoInstrumentPartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoInstrumentPartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoInstrumentPartySubIDs *)new FIX::NoInstrumentPartySubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoInstrumentPartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoInstrumentPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoInstrumentPartySubIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoInstrumentPartySubIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoInstrumentPartySubIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoInstrumentPartySubIDs::NoInstrumentPartySubIDs()\n"
    "    FIX::NoInstrumentPartySubIDs::NoInstrumentPartySubIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoInstrumentPartySubIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoInstrumentPartySubIDs *arg1 = (FIX::NoInstrumentPartySubIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoInstrumentPartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoInstrumentPartySubIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NoInstrumentPartySubIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoInstrumentPartySubIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingCurrentValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCurrentValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingCurrentValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCurrentValue *)new FIX::UnderlyingCurrentValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCurrentValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCurrentValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingCurrentValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingCurrentValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingCurrentValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingCurrentValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCurrentValue *)new FIX::UnderlyingCurrentValue((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCurrentValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCurrentValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingCurrentValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCurrentValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingCurrentValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingCurrentValue::UnderlyingCurrentValue()\n"
    "    FIX::UnderlyingCurrentValue::UnderlyingCurrentValue(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingCurrentValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCurrentValue *arg1 = (FIX::UnderlyingCurrentValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingCurrentValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingCurrentValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingCurrentValue" "', argument " "1"" of type '" "FIX::UnderlyingCurrentValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingCurrentValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_InterestAccrualDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InterestAccrualDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InterestAccrualDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InterestAccrualDate *)new FIX::InterestAccrualDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InterestAccrualDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterestAccrualDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InterestAccrualDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InterestAccrualDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InterestAccrualDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterestAccrualDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InterestAccrualDate *)new FIX::InterestAccrualDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InterestAccrualDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InterestAccrualDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InterestAccrualDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InterestAccrualDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InterestAccrualDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InterestAccrualDate::InterestAccrualDate()\n"
    "    FIX::InterestAccrualDate::InterestAccrualDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InterestAccrualDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InterestAccrualDate *arg1 = (FIX::InterestAccrualDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InterestAccrualDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InterestAccrualDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InterestAccrualDate" "', argument " "1"" of type '" "FIX::InterestAccrualDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InterestAccrualDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_FutSettDate2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FutSettDate2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FutSettDate2")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FutSettDate2 *)new FIX::FutSettDate2();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FutSettDate2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FutSettDate2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FutSettDate2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FutSettDate2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FutSettDate2" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FutSettDate2" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FutSettDate2 *)new FIX::FutSettDate2((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FutSettDate2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FutSettDate2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FutSettDate2__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FutSettDate2__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FutSettDate2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FutSettDate2::FutSettDate2()\n"
    "    FIX::FutSettDate2::FutSettDate2(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FutSettDate2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FutSettDate2 *arg1 = (FIX::FutSettDate2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FutSettDate2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FutSettDate2, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FutSettDate2" "', argument " "1"" of type '" "FIX::FutSettDate2 *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FutSettDate2 * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoClearingInstructions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoClearingInstructions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoClearingInstructions")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoClearingInstructions *)new FIX::NoClearingInstructions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoClearingInstructions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoClearingInstructions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoClearingInstructions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoClearingInstructions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoClearingInstructions" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoClearingInstructions" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoClearingInstructions *)new FIX::NoClearingInstructions((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoClearingInstructions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoClearingInstructions(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoClearingInstructions__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoClearingInstructions__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoClearingInstructions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoClearingInstructions::NoClearingInstructions()\n"
    "    FIX::NoClearingInstructions::NoClearingInstructions(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoClearingInstructions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoClearingInstructions *arg1 = (FIX::NoClearingInstructions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoClearingInstructions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoClearingInstructions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoClearingInstructions" "', argument " "1"" of type '" "FIX::NoClearingInstructions *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoClearingInstructions * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCurrency *)new FIX::UnderlyingCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCurrency *)new FIX::UnderlyingCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingCurrency::UnderlyingCurrency()\n"
    "    FIX::UnderlyingCurrency::UnderlyingCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCurrency *arg1 = (FIX::UnderlyingCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingCurrency" "', argument " "1"" of type '" "FIX::UnderlyingCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegInterestAccrualDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegInterestAccrualDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegInterestAccrualDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegInterestAccrualDate *)new FIX::LegInterestAccrualDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegInterestAccrualDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegInterestAccrualDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegInterestAccrualDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegInterestAccrualDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegInterestAccrualDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegInterestAccrualDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegInterestAccrualDate *)new FIX::LegInterestAccrualDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegInterestAccrualDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegInterestAccrualDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegInterestAccrualDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegInterestAccrualDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegInterestAccrualDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegInterestAccrualDate::LegInterestAccrualDate()\n"
    "    FIX::LegInterestAccrualDate::LegInterestAccrualDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegInterestAccrualDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegInterestAccrualDate *arg1 = (FIX::LegInterestAccrualDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegInterestAccrualDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegInterestAccrualDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegInterestAccrualDate" "', argument " "1"" of type '" "FIX::LegInterestAccrualDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegInterestAccrualDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NewPassword__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NewPassword *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NewPassword")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NewPassword *)new FIX::NewPassword();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NewPassword, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewPassword__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NewPassword *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NewPassword",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewPassword" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NewPassword" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NewPassword *)new FIX::NewPassword((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NewPassword, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewPassword(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NewPassword__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NewPassword__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NewPassword'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NewPassword::NewPassword()\n"
    "    FIX::NewPassword::NewPassword(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NewPassword(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NewPassword *arg1 = (FIX::NewPassword *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NewPassword",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NewPassword, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewPassword" "', argument " "1"" of type '" "FIX::NewPassword *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NewPassword * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RedemptionDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RedemptionDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RedemptionDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RedemptionDate *)new FIX::RedemptionDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RedemptionDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RedemptionDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RedemptionDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RedemptionDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RedemptionDate *)new FIX::RedemptionDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RedemptionDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RedemptionDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RedemptionDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RedemptionDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RedemptionDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RedemptionDate::RedemptionDate()\n"
    "    FIX::RedemptionDate::RedemptionDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RedemptionDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RedemptionDate *arg1 = (FIX::RedemptionDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RedemptionDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RedemptionDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RedemptionDate" "', argument " "1"" of type '" "FIX::RedemptionDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RedemptionDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RefApplLastSeqNum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefApplLastSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefApplLastSeqNum")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefApplLastSeqNum *)new FIX::RefApplLastSeqNum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefApplLastSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplLastSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefApplLastSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefApplLastSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SEQNUM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefApplLastSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefApplLastSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefApplLastSeqNum *)new FIX::RefApplLastSeqNum((FIX::SEQNUM const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefApplLastSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplLastSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefApplLastSeqNum__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefApplLastSeqNum__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefApplLastSeqNum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefApplLastSeqNum::RefApplLastSeqNum()\n"
    "    FIX::RefApplLastSeqNum::RefApplLastSeqNum(FIX::SEQNUM const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefApplLastSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefApplLastSeqNum *arg1 = (FIX::RefApplLastSeqNum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefApplLastSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefApplLastSeqNum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefApplLastSeqNum" "', argument " "1"" of type '" "FIX::RefApplLastSeqNum *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefApplLastSeqNum * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StartCash__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StartCash *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StartCash")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StartCash *)new FIX::StartCash();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StartCash, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartCash__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StartCash *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StartCash",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StartCash" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StartCash" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StartCash *)new FIX::StartCash((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StartCash, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartCash(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StartCash__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StartCash__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StartCash'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StartCash::StartCash()\n"
    "    FIX::StartCash::StartCash(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StartCash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StartCash *arg1 = (FIX::StartCash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StartCash",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StartCash, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StartCash" "', argument " "1"" of type '" "FIX::StartCash *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StartCash * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MaxMessageSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaxMessageSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaxMessageSize")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaxMessageSize *)new FIX::MaxMessageSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaxMessageSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxMessageSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaxMessageSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaxMessageSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaxMessageSize" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaxMessageSize" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaxMessageSize *)new FIX::MaxMessageSize((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaxMessageSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxMessageSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaxMessageSize__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaxMessageSize__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaxMessageSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaxMessageSize::MaxMessageSize()\n"
    "    FIX::MaxMessageSize::MaxMessageSize(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaxMessageSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaxMessageSize *arg1 = (FIX::MaxMessageSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaxMessageSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaxMessageSize, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaxMessageSize" "', argument " "1"" of type '" "FIX::MaxMessageSize *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaxMessageSize * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OfferForwardPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OfferForwardPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OfferForwardPoints")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OfferForwardPoints *)new FIX::OfferForwardPoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OfferForwardPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferForwardPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OfferForwardPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OfferForwardPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OfferForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OfferForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OfferForwardPoints *)new FIX::OfferForwardPoints((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OfferForwardPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferForwardPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OfferForwardPoints__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OfferForwardPoints__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OfferForwardPoints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OfferForwardPoints::OfferForwardPoints()\n"
    "    FIX::OfferForwardPoints::OfferForwardPoints(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OfferForwardPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OfferForwardPoints *arg1 = (FIX::OfferForwardPoints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OfferForwardPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OfferForwardPoints, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OfferForwardPoints" "', argument " "1"" of type '" "FIX::OfferForwardPoints *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OfferForwardPoints * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_IOIQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IOIQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIQty *)new FIX::IOIQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IOIQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IOIQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOIQty" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IOIQty" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIQty *)new FIX::IOIQty((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IOIQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IOIQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IOIQty::IOIQty()\n"
    "    FIX::IOIQty::IOIQty(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IOIQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIQty *arg1 = (FIX::IOIQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IOIQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IOIQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOIQty" "', argument " "1"" of type '" "FIX::IOIQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IOIQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LastQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastQty *)new FIX::LastQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastQty *)new FIX::LastQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastQty::LastQty()\n"
    "    FIX::LastQty::LastQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastQty *arg1 = (FIX::LastQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastQty" "', argument " "1"" of type '" "FIX::LastQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ApplResponseError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplResponseError *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplResponseError")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplResponseError *)new FIX::ApplResponseError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplResponseError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResponseError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplResponseError *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplResponseError",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplResponseError" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplResponseError" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplResponseError *)new FIX::ApplResponseError((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplResponseError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResponseError(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplResponseError__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplResponseError__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplResponseError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplResponseError::ApplResponseError()\n"
    "    FIX::ApplResponseError::ApplResponseError(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplResponseError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplResponseError *arg1 = (FIX::ApplResponseError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplResponseError",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplResponseError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplResponseError" "', argument " "1"" of type '" "FIX::ApplResponseError *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplResponseError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegSecurityType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecurityType *)new FIX::UnderlyingLegSecurityType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegSecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegSecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecurityType *)new FIX::UnderlyingLegSecurityType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegSecurityType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecurityType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegSecurityType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegSecurityType::UnderlyingLegSecurityType()\n"
    "    FIX::UnderlyingLegSecurityType::UnderlyingLegSecurityType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegSecurityType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecurityType *arg1 = (FIX::UnderlyingLegSecurityType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegSecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegSecurityType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegSecurityType" "', argument " "1"" of type '" "FIX::UnderlyingLegSecurityType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegSecurityType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativePriceUnitOfMeasure__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativePriceUnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativePriceUnitOfMeasure")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativePriceUnitOfMeasure *)new FIX::DerivativePriceUnitOfMeasure();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePriceUnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativePriceUnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativePriceUnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativePriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativePriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativePriceUnitOfMeasure *)new FIX::DerivativePriceUnitOfMeasure((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePriceUnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativePriceUnitOfMeasure__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativePriceUnitOfMeasure__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativePriceUnitOfMeasure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativePriceUnitOfMeasure::DerivativePriceUnitOfMeasure()\n"
    "    FIX::DerivativePriceUnitOfMeasure::DerivativePriceUnitOfMeasure(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativePriceUnitOfMeasure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativePriceUnitOfMeasure *arg1 = (FIX::DerivativePriceUnitOfMeasure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativePriceUnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasure, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativePriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::DerivativePriceUnitOfMeasure *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativePriceUnitOfMeasure * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TriggerPriceDirection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerPriceDirection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerPriceDirection")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerPriceDirection *)new FIX::TriggerPriceDirection();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerPriceDirection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPriceDirection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerPriceDirection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerPriceDirection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerPriceDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerPriceDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerPriceDirection *)new FIX::TriggerPriceDirection((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerPriceDirection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPriceDirection(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerPriceDirection__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerPriceDirection__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerPriceDirection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerPriceDirection::TriggerPriceDirection()\n"
    "    FIX::TriggerPriceDirection::TriggerPriceDirection(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerPriceDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerPriceDirection *arg1 = (FIX::TriggerPriceDirection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerPriceDirection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerPriceDirection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerPriceDirection" "', argument " "1"" of type '" "FIX::TriggerPriceDirection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerPriceDirection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PositionCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PositionCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PositionCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PositionCurrency *)new FIX::PositionCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PositionCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PositionCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PositionCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PositionCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PositionCurrency" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PositionCurrency" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PositionCurrency *)new FIX::PositionCurrency((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PositionCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PositionCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PositionCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PositionCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PositionCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PositionCurrency::PositionCurrency()\n"
    "    FIX::PositionCurrency::PositionCurrency(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PositionCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PositionCurrency *arg1 = (FIX::PositionCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PositionCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PositionCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PositionCurrency" "', argument " "1"" of type '" "FIX::PositionCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PositionCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MessageEventSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageEventSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MessageEventSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MessageEventSource *)new FIX::MessageEventSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageEventSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MessageEventSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MessageEventSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MessageEventSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MessageEventSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MessageEventSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MessageEventSource *)new FIX::MessageEventSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageEventSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MessageEventSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MessageEventSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MessageEventSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MessageEventSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MessageEventSource::MessageEventSource()\n"
    "    FIX::MessageEventSource::MessageEventSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MessageEventSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageEventSource *arg1 = (FIX::MessageEventSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MessageEventSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageEventSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageEventSource" "', argument " "1"" of type '" "FIX::MessageEventSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageEventSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CollInquiryID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollInquiryID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollInquiryID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollInquiryID *)new FIX::CollInquiryID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollInquiryID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollInquiryID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollInquiryID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollInquiryID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollInquiryID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollInquiryID *)new FIX::CollInquiryID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollInquiryID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollInquiryID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollInquiryID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollInquiryID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollInquiryID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollInquiryID::CollInquiryID()\n"
    "    FIX::CollInquiryID::CollInquiryID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollInquiryID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollInquiryID *arg1 = (FIX::CollInquiryID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollInquiryID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollInquiryID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollInquiryID" "', argument " "1"" of type '" "FIX::CollInquiryID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollInquiryID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingStartValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingStartValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingStartValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingStartValue *)new FIX::UnderlyingStartValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingStartValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStartValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingStartValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingStartValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingStartValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingStartValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingStartValue *)new FIX::UnderlyingStartValue((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingStartValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStartValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingStartValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingStartValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingStartValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingStartValue::UnderlyingStartValue()\n"
    "    FIX::UnderlyingStartValue::UnderlyingStartValue(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingStartValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingStartValue *arg1 = (FIX::UnderlyingStartValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingStartValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingStartValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingStartValue" "', argument " "1"" of type '" "FIX::UnderlyingStartValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingStartValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LastLiquidityInd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastLiquidityInd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastLiquidityInd")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastLiquidityInd *)new FIX::LastLiquidityInd();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastLiquidityInd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastLiquidityInd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastLiquidityInd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastLiquidityInd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastLiquidityInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastLiquidityInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastLiquidityInd *)new FIX::LastLiquidityInd((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastLiquidityInd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastLiquidityInd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastLiquidityInd__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastLiquidityInd__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastLiquidityInd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastLiquidityInd::LastLiquidityInd()\n"
    "    FIX::LastLiquidityInd::LastLiquidityInd(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastLiquidityInd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastLiquidityInd *arg1 = (FIX::LastLiquidityInd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastLiquidityInd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastLiquidityInd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastLiquidityInd" "', argument " "1"" of type '" "FIX::LastLiquidityInd *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastLiquidityInd * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecurityID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityID *)new FIX::SecurityID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityID *)new FIX::SecurityID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityID::SecurityID()\n"
    "    FIX::SecurityID::SecurityID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityID *arg1 = (FIX::SecurityID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityID" "', argument " "1"" of type '" "FIX::SecurityID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoMDEntries__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMDEntries *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoMDEntries")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMDEntries *)new FIX::NoMDEntries();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMDEntries, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMDEntries__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoMDEntries *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoMDEntries",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoMDEntries" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoMDEntries" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMDEntries *)new FIX::NoMDEntries((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMDEntries, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMDEntries(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoMDEntries__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMDEntries__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoMDEntries'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoMDEntries::NoMDEntries()\n"
    "    FIX::NoMDEntries::NoMDEntries(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoMDEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMDEntries *arg1 = (FIX::NoMDEntries *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoMDEntries",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoMDEntries, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoMDEntries" "', argument " "1"" of type '" "FIX::NoMDEntries *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoMDEntries * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StrikePriceDeterminationMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikePriceDeterminationMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StrikePriceDeterminationMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikePriceDeterminationMethod *)new FIX::StrikePriceDeterminationMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikePriceDeterminationMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePriceDeterminationMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrikePriceDeterminationMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrikePriceDeterminationMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrikePriceDeterminationMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrikePriceDeterminationMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikePriceDeterminationMethod *)new FIX::StrikePriceDeterminationMethod((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikePriceDeterminationMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePriceDeterminationMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StrikePriceDeterminationMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikePriceDeterminationMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StrikePriceDeterminationMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StrikePriceDeterminationMethod::StrikePriceDeterminationMethod()\n"
    "    FIX::StrikePriceDeterminationMethod::StrikePriceDeterminationMethod(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StrikePriceDeterminationMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikePriceDeterminationMethod *arg1 = (FIX::StrikePriceDeterminationMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrikePriceDeterminationMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StrikePriceDeterminationMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrikePriceDeterminationMethod" "', argument " "1"" of type '" "FIX::StrikePriceDeterminationMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StrikePriceDeterminationMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_EndDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EndDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EndDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EndDate *)new FIX::EndDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EndDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EndDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EndDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EndDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EndDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EndDate *)new FIX::EndDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EndDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EndDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EndDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EndDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EndDate::EndDate()\n"
    "    FIX::EndDate::EndDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EndDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EndDate *arg1 = (FIX::EndDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EndDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EndDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EndDate" "', argument " "1"" of type '" "FIX::EndDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EndDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CashOutstanding__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashOutstanding *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashOutstanding")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashOutstanding *)new FIX::CashOutstanding();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashOutstanding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashOutstanding__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashOutstanding *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashOutstanding",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashOutstanding" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashOutstanding" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashOutstanding *)new FIX::CashOutstanding((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashOutstanding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashOutstanding(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashOutstanding__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashOutstanding__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashOutstanding'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashOutstanding::CashOutstanding()\n"
    "    FIX::CashOutstanding::CashOutstanding(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashOutstanding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashOutstanding *arg1 = (FIX::CashOutstanding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashOutstanding",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashOutstanding, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashOutstanding" "', argument " "1"" of type '" "FIX::CashOutstanding *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashOutstanding * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDReqID *)new FIX::MDReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDReqID *)new FIX::MDReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDReqID::MDReqID()\n"
    "    FIX::MDReqID::MDReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDReqID *arg1 = (FIX::MDReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDReqID" "', argument " "1"" of type '" "FIX::MDReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_IOIRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IOIRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIRefID *)new FIX::IOIRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IOIRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IOIRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOIRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IOIRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIRefID *)new FIX::IOIRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IOIRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IOIRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IOIRefID::IOIRefID()\n"
    "    FIX::IOIRefID::IOIRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IOIRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIRefID *arg1 = (FIX::IOIRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IOIRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IOIRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOIRefID" "', argument " "1"" of type '" "FIX::IOIRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IOIRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TargetStrategy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetStrategy *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TargetStrategy")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetStrategy *)new FIX::TargetStrategy();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetStrategy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetStrategy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TargetStrategy *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TargetStrategy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TargetStrategy" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TargetStrategy" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetStrategy *)new FIX::TargetStrategy((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetStrategy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetStrategy(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TargetStrategy__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetStrategy__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TargetStrategy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TargetStrategy::TargetStrategy()\n"
    "    FIX::TargetStrategy::TargetStrategy(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TargetStrategy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetStrategy *arg1 = (FIX::TargetStrategy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TargetStrategy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TargetStrategy, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TargetStrategy" "', argument " "1"" of type '" "FIX::TargetStrategy *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TargetStrategy * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ConfirmRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfirmRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ConfirmRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfirmRefID *)new FIX::ConfirmRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfirmRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ConfirmRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ConfirmRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfirmRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConfirmRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfirmRefID *)new FIX::ConfirmRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfirmRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ConfirmRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfirmRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ConfirmRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ConfirmRefID::ConfirmRefID()\n"
    "    FIX::ConfirmRefID::ConfirmRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConfirmRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfirmRefID *arg1 = (FIX::ConfirmRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ConfirmRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ConfirmRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfirmRefID" "', argument " "1"" of type '" "FIX::ConfirmRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ConfirmRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SellerDays__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SellerDays *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SellerDays")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SellerDays *)new FIX::SellerDays();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SellerDays, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SellerDays__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SellerDays *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SellerDays",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SellerDays" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SellerDays" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SellerDays *)new FIX::SellerDays((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SellerDays, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SellerDays(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SellerDays__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SellerDays__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SellerDays'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SellerDays::SellerDays()\n"
    "    FIX::SellerDays::SellerDays(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SellerDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SellerDays *arg1 = (FIX::SellerDays *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SellerDays",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SellerDays, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SellerDays" "', argument " "1"" of type '" "FIX::SellerDays *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SellerDays * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DueToRelated__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DueToRelated *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DueToRelated")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DueToRelated *)new FIX::DueToRelated();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DueToRelated, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DueToRelated__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DueToRelated *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DueToRelated",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DueToRelated" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DueToRelated" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DueToRelated *)new FIX::DueToRelated((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DueToRelated, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DueToRelated(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DueToRelated__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DueToRelated__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DueToRelated'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DueToRelated::DueToRelated()\n"
    "    FIX::DueToRelated::DueToRelated(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DueToRelated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DueToRelated *arg1 = (FIX::DueToRelated *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DueToRelated",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DueToRelated, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DueToRelated" "', argument " "1"" of type '" "FIX::DueToRelated *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DueToRelated * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecondaryTradingReferencePrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryTradingReferencePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryTradingReferencePrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryTradingReferencePrice *)new FIX::SecondaryTradingReferencePrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryTradingReferencePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradingReferencePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryTradingReferencePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryTradingReferencePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryTradingReferencePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryTradingReferencePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryTradingReferencePrice *)new FIX::SecondaryTradingReferencePrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryTradingReferencePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradingReferencePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryTradingReferencePrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryTradingReferencePrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryTradingReferencePrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryTradingReferencePrice::SecondaryTradingReferencePrice()\n"
    "    FIX::SecondaryTradingReferencePrice::SecondaryTradingReferencePrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryTradingReferencePrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryTradingReferencePrice *arg1 = (FIX::SecondaryTradingReferencePrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryTradingReferencePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryTradingReferencePrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryTradingReferencePrice" "', argument " "1"" of type '" "FIX::SecondaryTradingReferencePrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryTradingReferencePrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoMDFeedTypes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMDFeedTypes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoMDFeedTypes")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMDFeedTypes *)new FIX::NoMDFeedTypes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMDFeedTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMDFeedTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoMDFeedTypes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoMDFeedTypes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoMDFeedTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoMDFeedTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMDFeedTypes *)new FIX::NoMDFeedTypes((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMDFeedTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMDFeedTypes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoMDFeedTypes__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMDFeedTypes__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoMDFeedTypes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoMDFeedTypes::NoMDFeedTypes()\n"
    "    FIX::NoMDFeedTypes::NoMDFeedTypes(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoMDFeedTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMDFeedTypes *arg1 = (FIX::NoMDFeedTypes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoMDFeedTypes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoMDFeedTypes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoMDFeedTypes" "', argument " "1"" of type '" "FIX::NoMDFeedTypes *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoMDFeedTypes * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartySubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingInstrumentPartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingInstrumentPartySubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingInstrumentPartySubIDType *)new FIX::UnderlyingInstrumentPartySubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingInstrumentPartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingInstrumentPartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingInstrumentPartySubIDType *)new FIX::UnderlyingInstrumentPartySubIDType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingInstrumentPartySubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingInstrumentPartySubIDType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingInstrumentPartySubIDType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingInstrumentPartySubIDType::UnderlyingInstrumentPartySubIDType()\n"
    "    FIX::UnderlyingInstrumentPartySubIDType::UnderlyingInstrumentPartySubIDType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingInstrumentPartySubIDType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingInstrumentPartySubIDType *arg1 = (FIX::UnderlyingInstrumentPartySubIDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingInstrumentPartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubIDType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::UnderlyingInstrumentPartySubIDType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingInstrumentPartySubIDType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradSesCloseTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesCloseTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradSesCloseTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesCloseTime *)new FIX::TradSesCloseTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesCloseTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesCloseTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesCloseTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesCloseTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TradSesCloseTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesCloseTime *)new FIX::TradSesCloseTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesCloseTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesCloseTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesCloseTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesCloseTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesCloseTime *)new FIX::TradSesCloseTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesCloseTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesCloseTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::TradSesCloseTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TradSesCloseTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TradSesCloseTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesCloseTime *)new FIX::TradSesCloseTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesCloseTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesCloseTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradSesCloseTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesCloseTime__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_TradSesCloseTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TradSesCloseTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradSesCloseTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradSesCloseTime::TradSesCloseTime()\n"
    "    FIX::TradSesCloseTime::TradSesCloseTime(bool)\n"
    "    FIX::TradSesCloseTime::TradSesCloseTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::TradSesCloseTime::TradSesCloseTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradSesCloseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesCloseTime *arg1 = (FIX::TradSesCloseTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradSesCloseTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradSesCloseTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradSesCloseTime" "', argument " "1"" of type '" "FIX::TradSesCloseTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradSesCloseTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ContractSettlMonth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContractSettlMonth *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ContractSettlMonth")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContractSettlMonth *)new FIX::ContractSettlMonth();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContractSettlMonth, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContractSettlMonth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContractSettlMonth *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContractSettlMonth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContractSettlMonth" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContractSettlMonth" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContractSettlMonth *)new FIX::ContractSettlMonth((FIX::MONTHYEAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContractSettlMonth, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContractSettlMonth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ContractSettlMonth__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContractSettlMonth__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContractSettlMonth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ContractSettlMonth::ContractSettlMonth()\n"
    "    FIX::ContractSettlMonth::ContractSettlMonth(FIX::MONTHYEAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ContractSettlMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContractSettlMonth *arg1 = (FIX::ContractSettlMonth *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContractSettlMonth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ContractSettlMonth, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContractSettlMonth" "', argument " "1"" of type '" "FIX::ContractSettlMonth *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ContractSettlMonth * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeStrikePrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeStrikePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeStrikePrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeStrikePrice *)new FIX::DerivativeStrikePrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeStrikePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeStrikePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeStrikePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeStrikePrice *)new FIX::DerivativeStrikePrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeStrikePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeStrikePrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeStrikePrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeStrikePrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeStrikePrice::DerivativeStrikePrice()\n"
    "    FIX::DerivativeStrikePrice::DerivativeStrikePrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeStrikePrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeStrikePrice *arg1 = (FIX::DerivativeStrikePrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeStrikePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeStrikePrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeStrikePrice" "', argument " "1"" of type '" "FIX::DerivativeStrikePrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeStrikePrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TriggerSecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerSecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerSecurityDesc *)new FIX::TriggerSecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerSecurityDesc *)new FIX::TriggerSecurityDesc((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerSecurityDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerSecurityDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerSecurityDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerSecurityDesc::TriggerSecurityDesc()\n"
    "    FIX::TriggerSecurityDesc::TriggerSecurityDesc(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerSecurityDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerSecurityDesc *arg1 = (FIX::TriggerSecurityDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerSecurityDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerSecurityDesc" "', argument " "1"" of type '" "FIX::TriggerSecurityDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerSecurityDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingCashType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCashType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingCashType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCashType *)new FIX::UnderlyingCashType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCashType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCashType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingCashType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingCashType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingCashType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingCashType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCashType *)new FIX::UnderlyingCashType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCashType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCashType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingCashType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCashType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingCashType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingCashType::UnderlyingCashType()\n"
    "    FIX::UnderlyingCashType::UnderlyingCashType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingCashType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCashType *arg1 = (FIX::UnderlyingCashType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingCashType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingCashType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingCashType" "', argument " "1"" of type '" "FIX::UnderlyingCashType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingCashType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoMiscFees__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMiscFees *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoMiscFees")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMiscFees *)new FIX::NoMiscFees();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMiscFees, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMiscFees__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoMiscFees *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoMiscFees",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoMiscFees" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoMiscFees" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMiscFees *)new FIX::NoMiscFees((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMiscFees, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMiscFees(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoMiscFees__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMiscFees__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoMiscFees'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoMiscFees::NoMiscFees()\n"
    "    FIX::NoMiscFees::NoMiscFees(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoMiscFees(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMiscFees *arg1 = (FIX::NoMiscFees *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoMiscFees",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoMiscFees, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoMiscFees" "', argument " "1"" of type '" "FIX::NoMiscFees *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoMiscFees * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CustOrderCapacity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CustOrderCapacity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CustOrderCapacity")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CustOrderCapacity *)new FIX::CustOrderCapacity();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CustOrderCapacity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustOrderCapacity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CustOrderCapacity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CustOrderCapacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustOrderCapacity" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustOrderCapacity" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CustOrderCapacity *)new FIX::CustOrderCapacity((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CustOrderCapacity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustOrderCapacity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CustOrderCapacity__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CustOrderCapacity__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CustOrderCapacity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CustOrderCapacity::CustOrderCapacity()\n"
    "    FIX::CustOrderCapacity::CustOrderCapacity(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CustOrderCapacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CustOrderCapacity *arg1 = (FIX::CustOrderCapacity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CustOrderCapacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CustOrderCapacity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CustOrderCapacity" "', argument " "1"" of type '" "FIX::CustOrderCapacity *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CustOrderCapacity * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegAllocSettlCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegAllocSettlCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegAllocSettlCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegAllocSettlCurrency *)new FIX::LegAllocSettlCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegAllocSettlCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocSettlCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegAllocSettlCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegAllocSettlCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegAllocSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegAllocSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegAllocSettlCurrency *)new FIX::LegAllocSettlCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegAllocSettlCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocSettlCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegAllocSettlCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegAllocSettlCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegAllocSettlCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegAllocSettlCurrency::LegAllocSettlCurrency()\n"
    "    FIX::LegAllocSettlCurrency::LegAllocSettlCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegAllocSettlCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegAllocSettlCurrency *arg1 = (FIX::LegAllocSettlCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegAllocSettlCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegAllocSettlCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegAllocSettlCurrency" "', argument " "1"" of type '" "FIX::LegAllocSettlCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegAllocSettlCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingAdjustedQuantity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingAdjustedQuantity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingAdjustedQuantity")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingAdjustedQuantity *)new FIX::UnderlyingAdjustedQuantity();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingAdjustedQuantity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingAdjustedQuantity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingAdjustedQuantity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingAdjustedQuantity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingAdjustedQuantity" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingAdjustedQuantity" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingAdjustedQuantity *)new FIX::UnderlyingAdjustedQuantity((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingAdjustedQuantity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingAdjustedQuantity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingAdjustedQuantity__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingAdjustedQuantity__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingAdjustedQuantity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingAdjustedQuantity::UnderlyingAdjustedQuantity()\n"
    "    FIX::UnderlyingAdjustedQuantity::UnderlyingAdjustedQuantity(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingAdjustedQuantity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingAdjustedQuantity *arg1 = (FIX::UnderlyingAdjustedQuantity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingAdjustedQuantity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingAdjustedQuantity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingAdjustedQuantity" "', argument " "1"" of type '" "FIX::UnderlyingAdjustedQuantity *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingAdjustedQuantity * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OwnershipType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OwnershipType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OwnershipType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OwnershipType *)new FIX::OwnershipType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OwnershipType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OwnershipType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OwnershipType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OwnershipType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OwnershipType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OwnershipType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OwnershipType *)new FIX::OwnershipType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OwnershipType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OwnershipType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OwnershipType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OwnershipType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OwnershipType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OwnershipType::OwnershipType()\n"
    "    FIX::OwnershipType::OwnershipType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OwnershipType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OwnershipType *arg1 = (FIX::OwnershipType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OwnershipType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OwnershipType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OwnershipType" "', argument " "1"" of type '" "FIX::OwnershipType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OwnershipType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MaxShow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaxShow *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaxShow")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaxShow *)new FIX::MaxShow();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaxShow, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxShow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaxShow *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaxShow",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaxShow" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaxShow" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaxShow *)new FIX::MaxShow((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaxShow, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxShow(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaxShow__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaxShow__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaxShow'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaxShow::MaxShow()\n"
    "    FIX::MaxShow::MaxShow(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaxShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaxShow *arg1 = (FIX::MaxShow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaxShow",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaxShow, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaxShow" "', argument " "1"" of type '" "FIX::MaxShow *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaxShow * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegSecurityID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSecurityID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecurityID *)new FIX::LegSecurityID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecurityID *)new FIX::LegSecurityID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSecurityID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecurityID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSecurityID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSecurityID::LegSecurityID()\n"
    "    FIX::LegSecurityID::LegSecurityID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSecurityID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecurityID *arg1 = (FIX::LegSecurityID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSecurityID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSecurityID" "', argument " "1"" of type '" "FIX::LegSecurityID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSecurityID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeSecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityDesc *)new FIX::DerivativeSecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityDesc *)new FIX::DerivativeSecurityDesc((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSecurityDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSecurityDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSecurityDesc::DerivativeSecurityDesc()\n"
    "    FIX::DerivativeSecurityDesc::DerivativeSecurityDesc(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSecurityDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityDesc *arg1 = (FIX::DerivativeSecurityDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSecurityDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSecurityDesc" "', argument " "1"" of type '" "FIX::DerivativeSecurityDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSecurityDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnitOfMeasure__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnitOfMeasure")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnitOfMeasure *)new FIX::UnitOfMeasure();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnitOfMeasure *)new FIX::UnitOfMeasure((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnitOfMeasure__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnitOfMeasure__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnitOfMeasure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnitOfMeasure::UnitOfMeasure()\n"
    "    FIX::UnitOfMeasure::UnitOfMeasure(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnitOfMeasure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnitOfMeasure *arg1 = (FIX::UnitOfMeasure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnitOfMeasure, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnitOfMeasure" "', argument " "1"" of type '" "FIX::UnitOfMeasure *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnitOfMeasure * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Quantity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Quantity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Quantity")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Quantity *)new FIX::Quantity();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Quantity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Quantity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Quantity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Quantity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Quantity" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Quantity" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Quantity *)new FIX::Quantity((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Quantity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Quantity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Quantity__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Quantity__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Quantity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Quantity::Quantity()\n"
    "    FIX::Quantity::Quantity(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Quantity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Quantity *arg1 = (FIX::Quantity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Quantity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Quantity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Quantity" "', argument " "1"" of type '" "FIX::Quantity *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Quantity * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NewsID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NewsID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NewsID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NewsID *)new FIX::NewsID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NewsID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NewsID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NewsID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewsID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NewsID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NewsID *)new FIX::NewsID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NewsID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NewsID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NewsID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NewsID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NewsID::NewsID()\n"
    "    FIX::NewsID::NewsID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NewsID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NewsID *arg1 = (FIX::NewsID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NewsID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NewsID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewsID" "', argument " "1"" of type '" "FIX::NewsID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NewsID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartySubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UndlyInstrumentPartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UndlyInstrumentPartySubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UndlyInstrumentPartySubIDType *)new FIX::UndlyInstrumentPartySubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UndlyInstrumentPartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UndlyInstrumentPartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UndlyInstrumentPartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UndlyInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UndlyInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UndlyInstrumentPartySubIDType *)new FIX::UndlyInstrumentPartySubIDType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UndlyInstrumentPartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UndlyInstrumentPartySubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UndlyInstrumentPartySubIDType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UndlyInstrumentPartySubIDType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UndlyInstrumentPartySubIDType::UndlyInstrumentPartySubIDType()\n"
    "    FIX::UndlyInstrumentPartySubIDType::UndlyInstrumentPartySubIDType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UndlyInstrumentPartySubIDType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UndlyInstrumentPartySubIDType *arg1 = (FIX::UndlyInstrumentPartySubIDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UndlyInstrumentPartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UndlyInstrumentPartySubIDType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UndlyInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::UndlyInstrumentPartySubIDType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UndlyInstrumentPartySubIDType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettleOnOpenFlag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettleOnOpenFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettleOnOpenFlag")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettleOnOpenFlag *)new FIX::SettleOnOpenFlag();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettleOnOpenFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettleOnOpenFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettleOnOpenFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettleOnOpenFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettleOnOpenFlag" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettleOnOpenFlag" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettleOnOpenFlag *)new FIX::SettleOnOpenFlag((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettleOnOpenFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettleOnOpenFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettleOnOpenFlag__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettleOnOpenFlag__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettleOnOpenFlag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettleOnOpenFlag::SettleOnOpenFlag()\n"
    "    FIX::SettleOnOpenFlag::SettleOnOpenFlag(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettleOnOpenFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettleOnOpenFlag *arg1 = (FIX::SettleOnOpenFlag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettleOnOpenFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettleOnOpenFlag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettleOnOpenFlag" "', argument " "1"" of type '" "FIX::SettleOnOpenFlag *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettleOnOpenFlag * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LastUpdateTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastUpdateTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastUpdateTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastUpdateTime *)new FIX::LastUpdateTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastUpdateTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastUpdateTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastUpdateTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastUpdateTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LastUpdateTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastUpdateTime *)new FIX::LastUpdateTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastUpdateTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastUpdateTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastUpdateTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastUpdateTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastUpdateTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastUpdateTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastUpdateTime *)new FIX::LastUpdateTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastUpdateTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastUpdateTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::LastUpdateTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_LastUpdateTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastUpdateTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastUpdateTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LastUpdateTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastUpdateTime *)new FIX::LastUpdateTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastUpdateTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastUpdateTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastUpdateTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastUpdateTime__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_LastUpdateTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LastUpdateTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastUpdateTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastUpdateTime::LastUpdateTime()\n"
    "    FIX::LastUpdateTime::LastUpdateTime(bool)\n"
    "    FIX::LastUpdateTime::LastUpdateTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::LastUpdateTime::LastUpdateTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastUpdateTime *arg1 = (FIX::LastUpdateTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastUpdateTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastUpdateTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastUpdateTime" "', argument " "1"" of type '" "FIX::LastUpdateTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastUpdateTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RepurchaseRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepurchaseRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RepurchaseRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RepurchaseRate *)new FIX::RepurchaseRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepurchaseRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepurchaseRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RepurchaseRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RepurchaseRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RepurchaseRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RepurchaseRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RepurchaseRate *)new FIX::RepurchaseRate((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepurchaseRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepurchaseRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RepurchaseRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RepurchaseRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RepurchaseRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RepurchaseRate::RepurchaseRate()\n"
    "    FIX::RepurchaseRate::RepurchaseRate(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RepurchaseRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepurchaseRate *arg1 = (FIX::RepurchaseRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RepurchaseRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RepurchaseRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RepurchaseRate" "', argument " "1"" of type '" "FIX::RepurchaseRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RepurchaseRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_RepurchaseTerm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepurchaseTerm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RepurchaseTerm")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RepurchaseTerm *)new FIX::RepurchaseTerm();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepurchaseTerm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepurchaseTerm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RepurchaseTerm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RepurchaseTerm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RepurchaseTerm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RepurchaseTerm" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RepurchaseTerm *)new FIX::RepurchaseTerm((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepurchaseTerm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepurchaseTerm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RepurchaseTerm__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RepurchaseTerm__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RepurchaseTerm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RepurchaseTerm::RepurchaseTerm()\n"
    "    FIX::RepurchaseTerm::RepurchaseTerm(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RepurchaseTerm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepurchaseTerm *arg1 = (FIX::RepurchaseTerm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RepurchaseTerm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RepurchaseTerm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RepurchaseTerm" "', argument " "1"" of type '" "FIX::RepurchaseTerm *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RepurchaseTerm * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NestedPartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NestedPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NestedPartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NestedPartyRole *)new FIX::NestedPartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NestedPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NestedPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NestedPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NestedPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NestedPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NestedPartyRole *)new FIX::NestedPartyRole((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NestedPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NestedPartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NestedPartyRole__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NestedPartyRole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NestedPartyRole::NestedPartyRole()\n"
    "    FIX::NestedPartyRole::NestedPartyRole(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NestedPartyRole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NestedPartyRole *arg1 = (FIX::NestedPartyRole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NestedPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NestedPartyRole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NestedPartyRole" "', argument " "1"" of type '" "FIX::NestedPartyRole *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NestedPartyRole * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SecondaryExecID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryExecID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryExecID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryExecID *)new FIX::SecondaryExecID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryExecID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryExecID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryExecID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryExecID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryExecID *)new FIX::SecondaryExecID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryExecID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryExecID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryExecID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryExecID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryExecID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryExecID::SecondaryExecID()\n"
    "    FIX::SecondaryExecID::SecondaryExecID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryExecID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryExecID *arg1 = (FIX::SecondaryExecID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryExecID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryExecID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryExecID" "', argument " "1"" of type '" "FIX::SecondaryExecID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryExecID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Pool__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Pool *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Pool")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Pool *)new FIX::Pool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Pool, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pool__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Pool *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Pool",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Pool" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Pool" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Pool *)new FIX::Pool((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Pool, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pool(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Pool__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Pool__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Pool'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Pool::Pool()\n"
    "    FIX::Pool::Pool(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Pool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Pool *arg1 = (FIX::Pool *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Pool",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Pool, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Pool" "', argument " "1"" of type '" "FIX::Pool *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Pool * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoTickRules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTickRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoTickRules")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTickRules *)new FIX::NoTickRules();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTickRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTickRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoTickRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoTickRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoTickRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoTickRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTickRules *)new FIX::NoTickRules((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTickRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTickRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoTickRules__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTickRules__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoTickRules'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoTickRules::NoTickRules()\n"
    "    FIX::NoTickRules::NoTickRules(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoTickRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTickRules *arg1 = (FIX::NoTickRules *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoTickRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoTickRules, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoTickRules" "', argument " "1"" of type '" "FIX::NoTickRules *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoTickRules * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Volatility__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Volatility *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Volatility")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Volatility *)new FIX::Volatility();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Volatility, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Volatility__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Volatility *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Volatility",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Volatility" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Volatility" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Volatility *)new FIX::Volatility((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Volatility, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Volatility(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Volatility__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Volatility__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Volatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Volatility::Volatility()\n"
    "    FIX::Volatility::Volatility(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Volatility(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Volatility *arg1 = (FIX::Volatility *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Volatility",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Volatility, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Volatility" "', argument " "1"" of type '" "FIX::Volatility *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Volatility * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PctAtRisk__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PctAtRisk *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PctAtRisk")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PctAtRisk *)new FIX::PctAtRisk();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PctAtRisk, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PctAtRisk__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PctAtRisk *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PctAtRisk",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PctAtRisk" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PctAtRisk" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PctAtRisk *)new FIX::PctAtRisk((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PctAtRisk, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PctAtRisk(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PctAtRisk__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PctAtRisk__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PctAtRisk'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PctAtRisk::PctAtRisk()\n"
    "    FIX::PctAtRisk::PctAtRisk(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PctAtRisk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PctAtRisk *arg1 = (FIX::PctAtRisk *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PctAtRisk",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PctAtRisk, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PctAtRisk" "', argument " "1"" of type '" "FIX::PctAtRisk *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PctAtRisk * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityExchange__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecurityExchange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSecurityExchange")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecurityExchange *)new FIX::UnderlyingSecurityExchange();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecurityExchange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityExchange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSecurityExchange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSecurityExchange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecurityExchange *)new FIX::UnderlyingSecurityExchange((FIX::EXCHANGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecurityExchange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityExchange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSecurityExchange__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecurityExchange__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSecurityExchange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSecurityExchange::UnderlyingSecurityExchange()\n"
    "    FIX::UnderlyingSecurityExchange::UnderlyingSecurityExchange(FIX::EXCHANGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSecurityExchange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecurityExchange *arg1 = (FIX::UnderlyingSecurityExchange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSecurityExchange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSecurityExchange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSecurityExchange" "', argument " "1"" of type '" "FIX::UnderlyingSecurityExchange *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSecurityExchange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegStrikePrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegStrikePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegStrikePrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegStrikePrice *)new FIX::LegStrikePrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegStrikePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStrikePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegStrikePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegStrikePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegStrikePrice *)new FIX::LegStrikePrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegStrikePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStrikePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegStrikePrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegStrikePrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegStrikePrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegStrikePrice::LegStrikePrice()\n"
    "    FIX::LegStrikePrice::LegStrikePrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegStrikePrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegStrikePrice *arg1 = (FIX::LegStrikePrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegStrikePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegStrikePrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegStrikePrice" "', argument " "1"" of type '" "FIX::LegStrikePrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegStrikePrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlmntTyp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlmntTyp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlmntTyp")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlmntTyp *)new FIX::SettlmntTyp();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlmntTyp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlmntTyp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlmntTyp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlmntTyp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlmntTyp" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlmntTyp" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlmntTyp *)new FIX::SettlmntTyp((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlmntTyp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlmntTyp(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlmntTyp__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlmntTyp__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlmntTyp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlmntTyp::SettlmntTyp()\n"
    "    FIX::SettlmntTyp::SettlmntTyp(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlmntTyp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlmntTyp *arg1 = (FIX::SettlmntTyp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlmntTyp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlmntTyp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlmntTyp" "', argument " "1"" of type '" "FIX::SettlmntTyp *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlmntTyp * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TradePublishIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradePublishIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradePublishIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradePublishIndicator *)new FIX::TradePublishIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradePublishIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradePublishIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradePublishIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradePublishIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradePublishIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradePublishIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradePublishIndicator *)new FIX::TradePublishIndicator((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradePublishIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradePublishIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradePublishIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradePublishIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradePublishIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradePublishIndicator::TradePublishIndicator()\n"
    "    FIX::TradePublishIndicator::TradePublishIndicator(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradePublishIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradePublishIndicator *arg1 = (FIX::TradePublishIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradePublishIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradePublishIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradePublishIndicator" "', argument " "1"" of type '" "FIX::TradePublishIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradePublishIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ApplResponseType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplResponseType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplResponseType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplResponseType *)new FIX::ApplResponseType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplResponseType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResponseType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplResponseType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplResponseType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplResponseType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplResponseType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplResponseType *)new FIX::ApplResponseType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplResponseType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResponseType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplResponseType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplResponseType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplResponseType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplResponseType::ApplResponseType()\n"
    "    FIX::ApplResponseType::ApplResponseType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplResponseType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplResponseType *arg1 = (FIX::ApplResponseType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplResponseType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplResponseType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplResponseType" "', argument " "1"" of type '" "FIX::ApplResponseType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplResponseType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MDSubBookType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDSubBookType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDSubBookType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDSubBookType *)new FIX::MDSubBookType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDSubBookType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDSubBookType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDSubBookType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDSubBookType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDSubBookType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDSubBookType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDSubBookType *)new FIX::MDSubBookType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDSubBookType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDSubBookType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDSubBookType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDSubBookType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDSubBookType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDSubBookType::MDSubBookType()\n"
    "    FIX::MDSubBookType::MDSubBookType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDSubBookType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDSubBookType *arg1 = (FIX::MDSubBookType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDSubBookType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDSubBookType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDSubBookType" "', argument " "1"" of type '" "FIX::MDSubBookType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDSubBookType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Username__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Username *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Username")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Username *)new FIX::Username();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Username, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Username__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Username *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Username",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Username" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Username" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Username *)new FIX::Username((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Username, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Username(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Username__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Username__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Username'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Username::Username()\n"
    "    FIX::Username::Username(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Username(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Username *arg1 = (FIX::Username *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Username",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Username, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Username" "', argument " "1"" of type '" "FIX::Username *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Username * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StandInstDbType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StandInstDbType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StandInstDbType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StandInstDbType *)new FIX::StandInstDbType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StandInstDbType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StandInstDbType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StandInstDbType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StandInstDbType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StandInstDbType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StandInstDbType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StandInstDbType *)new FIX::StandInstDbType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StandInstDbType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StandInstDbType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StandInstDbType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StandInstDbType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StandInstDbType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StandInstDbType::StandInstDbType()\n"
    "    FIX::StandInstDbType::StandInstDbType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StandInstDbType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StandInstDbType *arg1 = (FIX::StandInstDbType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StandInstDbType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StandInstDbType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StandInstDbType" "', argument " "1"" of type '" "FIX::StandInstDbType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StandInstDbType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_QuoteEntryStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteEntryStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteEntryStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteEntryStatus *)new FIX::QuoteEntryStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteEntryStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteEntryStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteEntryStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteEntryStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteEntryStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteEntryStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteEntryStatus *)new FIX::QuoteEntryStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteEntryStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteEntryStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteEntryStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteEntryStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteEntryStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteEntryStatus::QuoteEntryStatus()\n"
    "    FIX::QuoteEntryStatus::QuoteEntryStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteEntryStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteEntryStatus *arg1 = (FIX::QuoteEntryStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteEntryStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteEntryStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteEntryStatus" "', argument " "1"" of type '" "FIX::QuoteEntryStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteEntryStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TriggerPriceType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerPriceType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerPriceType *)new FIX::TriggerPriceType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerPriceType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerPriceType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerPriceType *)new FIX::TriggerPriceType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerPriceType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerPriceType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerPriceType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerPriceType::TriggerPriceType()\n"
    "    FIX::TriggerPriceType::TriggerPriceType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerPriceType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerPriceType *arg1 = (FIX::TriggerPriceType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerPriceType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerPriceType" "', argument " "1"" of type '" "FIX::TriggerPriceType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerPriceType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SideTrdSubTyp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideTrdSubTyp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideTrdSubTyp")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTrdSubTyp *)new FIX::SideTrdSubTyp();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTrdSubTyp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdSubTyp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideTrdSubTyp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideTrdSubTyp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideTrdSubTyp" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideTrdSubTyp" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTrdSubTyp *)new FIX::SideTrdSubTyp((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTrdSubTyp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdSubTyp(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideTrdSubTyp__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideTrdSubTyp__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideTrdSubTyp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideTrdSubTyp::SideTrdSubTyp()\n"
    "    FIX::SideTrdSubTyp::SideTrdSubTyp(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideTrdSubTyp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideTrdSubTyp *arg1 = (FIX::SideTrdSubTyp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideTrdSubTyp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideTrdSubTyp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideTrdSubTyp" "', argument " "1"" of type '" "FIX::SideTrdSubTyp *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideTrdSubTyp * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingTradingSessionSubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingTradingSessionSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingTradingSessionSubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingTradingSessionSubID *)new FIX::UnderlyingTradingSessionSubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingTradingSessionSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingTradingSessionSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingTradingSessionSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingTradingSessionSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingTradingSessionSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingTradingSessionSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingTradingSessionSubID *)new FIX::UnderlyingTradingSessionSubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingTradingSessionSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingTradingSessionSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingTradingSessionSubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingTradingSessionSubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingTradingSessionSubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingTradingSessionSubID::UnderlyingTradingSessionSubID()\n"
    "    FIX::UnderlyingTradingSessionSubID::UnderlyingTradingSessionSubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingTradingSessionSubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingTradingSessionSubID *arg1 = (FIX::UnderlyingTradingSessionSubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingTradingSessionSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingTradingSessionSubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingTradingSessionSubID" "', argument " "1"" of type '" "FIX::UnderlyingTradingSessionSubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingTradingSessionSubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SettlInstReqRejCode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstReqRejCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlInstReqRejCode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstReqRejCode *)new FIX::SettlInstReqRejCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstReqRejCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstReqRejCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlInstReqRejCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlInstReqRejCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlInstReqRejCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlInstReqRejCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstReqRejCode *)new FIX::SettlInstReqRejCode((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstReqRejCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstReqRejCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlInstReqRejCode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstReqRejCode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlInstReqRejCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlInstReqRejCode::SettlInstReqRejCode()\n"
    "    FIX::SettlInstReqRejCode::SettlInstReqRejCode(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlInstReqRejCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstReqRejCode *arg1 = (FIX::SettlInstReqRejCode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlInstReqRejCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlInstReqRejCode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlInstReqRejCode" "', argument " "1"" of type '" "FIX::SettlInstReqRejCode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlInstReqRejCode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MktBidPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MktBidPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MktBidPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MktBidPx *)new FIX::MktBidPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MktBidPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MktBidPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MktBidPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MktBidPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MktBidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MktBidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MktBidPx *)new FIX::MktBidPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MktBidPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MktBidPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MktBidPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MktBidPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MktBidPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MktBidPx::MktBidPx()\n"
    "    FIX::MktBidPx::MktBidPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MktBidPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MktBidPx *arg1 = (FIX::MktBidPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MktBidPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MktBidPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MktBidPx" "', argument " "1"" of type '" "FIX::MktBidPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MktBidPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingLegSymbol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSymbol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegSymbol")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSymbol *)new FIX::UnderlyingLegSymbol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSymbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSymbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegSymbol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegSymbol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSymbol *)new FIX::UnderlyingLegSymbol((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSymbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegSymbol__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSymbol__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegSymbol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegSymbol::UnderlyingLegSymbol()\n"
    "    FIX::UnderlyingLegSymbol::UnderlyingLegSymbol(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSymbol *arg1 = (FIX::UnderlyingLegSymbol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegSymbol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegSymbol, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegSymbol" "', argument " "1"" of type '" "FIX::UnderlyingLegSymbol *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_StrikeValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikeValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StrikeValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeValue *)new FIX::StrikeValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrikeValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrikeValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrikeValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrikeValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikeValue *)new FIX::StrikeValue((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikeValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikeValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StrikeValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikeValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StrikeValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StrikeValue::StrikeValue()\n"
    "    FIX::StrikeValue::StrikeValue(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StrikeValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikeValue *arg1 = (FIX::StrikeValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrikeValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StrikeValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrikeValue" "', argument " "1"" of type '" "FIX::StrikeValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StrikeValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Urgency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Urgency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Urgency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Urgency *)new FIX::Urgency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Urgency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Urgency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Urgency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Urgency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Urgency" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Urgency" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Urgency *)new FIX::Urgency((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Urgency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Urgency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Urgency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Urgency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Urgency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Urgency::Urgency()\n"
    "    FIX::Urgency::Urgency(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Urgency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Urgency *arg1 = (FIX::Urgency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Urgency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Urgency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Urgency" "', argument " "1"" of type '" "FIX::Urgency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Urgency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AllocID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocID *)new FIX::AllocID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocID *)new FIX::AllocID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocID::AllocID()\n"
    "    FIX::AllocID::AllocID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocID *arg1 = (FIX::AllocID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocID" "', argument " "1"" of type '" "FIX::AllocID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingDeliveryAmount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingDeliveryAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingDeliveryAmount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingDeliveryAmount *)new FIX::UnderlyingDeliveryAmount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingDeliveryAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingDeliveryAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingDeliveryAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingDeliveryAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingDeliveryAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingDeliveryAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingDeliveryAmount *)new FIX::UnderlyingDeliveryAmount((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingDeliveryAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingDeliveryAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingDeliveryAmount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingDeliveryAmount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingDeliveryAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingDeliveryAmount::UnderlyingDeliveryAmount()\n"
    "    FIX::UnderlyingDeliveryAmount::UnderlyingDeliveryAmount(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingDeliveryAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingDeliveryAmount *arg1 = (FIX::UnderlyingDeliveryAmount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingDeliveryAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingDeliveryAmount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingDeliveryAmount" "', argument " "1"" of type '" "FIX::UnderlyingDeliveryAmount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingDeliveryAmount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_SideQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideQty *)new FIX::SideQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideQty" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideQty" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideQty *)new FIX::SideQty((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideQty::SideQty()\n"
    "    FIX::SideQty::SideQty(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideQty *arg1 = (FIX::SideQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideQty" "', argument " "1"" of type '" "FIX::SideQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_CollAsgnTransType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollAsgnTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollAsgnTransType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollAsgnTransType *)new FIX::CollAsgnTransType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollAsgnTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollAsgnTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollAsgnTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollAsgnTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollAsgnTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollAsgnTransType *)new FIX::CollAsgnTransType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollAsgnTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollAsgnTransType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollAsgnTransType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollAsgnTransType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollAsgnTransType::CollAsgnTransType()\n"
    "    FIX::CollAsgnTransType::CollAsgnTransType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollAsgnTransType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollAsgnTransType *arg1 = (FIX::CollAsgnTransType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollAsgnTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollAsgnTransType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollAsgnTransType" "', argument " "1"" of type '" "FIX::CollAsgnTransType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollAsgnTransType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ThresholdAmount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ThresholdAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ThresholdAmount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ThresholdAmount *)new FIX::ThresholdAmount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ThresholdAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ThresholdAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ThresholdAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ThresholdAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ThresholdAmount" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ThresholdAmount" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ThresholdAmount *)new FIX::ThresholdAmount((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ThresholdAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ThresholdAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ThresholdAmount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ThresholdAmount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ThresholdAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ThresholdAmount::ThresholdAmount()\n"
    "    FIX::ThresholdAmount::ThresholdAmount(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ThresholdAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ThresholdAmount *arg1 = (FIX::ThresholdAmount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ThresholdAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ThresholdAmount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ThresholdAmount" "', argument " "1"" of type '" "FIX::ThresholdAmount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ThresholdAmount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DefBidSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DefBidSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DefBidSize")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DefBidSize *)new FIX::DefBidSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DefBidSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefBidSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DefBidSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DefBidSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DefBidSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefBidSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DefBidSize *)new FIX::DefBidSize((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DefBidSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefBidSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DefBidSize__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefBidSize__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DefBidSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DefBidSize::DefBidSize()\n"
    "    FIX::DefBidSize::DefBidSize(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DefBidSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DefBidSize *arg1 = (FIX::DefBidSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DefBidSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DefBidSize, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefBidSize" "', argument " "1"" of type '" "FIX::DefBidSize *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DefBidSize * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegStateOrProvinceOfIssue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegStateOrProvinceOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegStateOrProvinceOfIssue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegStateOrProvinceOfIssue *)new FIX::LegStateOrProvinceOfIssue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegStateOrProvinceOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStateOrProvinceOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegStateOrProvinceOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegStateOrProvinceOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegStateOrProvinceOfIssue *)new FIX::LegStateOrProvinceOfIssue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegStateOrProvinceOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStateOrProvinceOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegStateOrProvinceOfIssue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegStateOrProvinceOfIssue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegStateOrProvinceOfIssue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegStateOrProvinceOfIssue::LegStateOrProvinceOfIssue()\n"
    "    FIX::LegStateOrProvinceOfIssue::LegStateOrProvinceOfIssue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegStateOrProvinceOfIssue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegStateOrProvinceOfIssue *arg1 = (FIX::LegStateOrProvinceOfIssue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegStateOrProvinceOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegStateOrProvinceOfIssue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegStateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::LegStateOrProvinceOfIssue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegStateOrProvinceOfIssue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PaymentMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PaymentMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PaymentMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PaymentMethod *)new FIX::PaymentMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PaymentMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PaymentMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PaymentMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PaymentMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PaymentMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PaymentMethod *)new FIX::PaymentMethod((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PaymentMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PaymentMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PaymentMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PaymentMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PaymentMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PaymentMethod::PaymentMethod()\n"
    "    FIX::PaymentMethod::PaymentMethod(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PaymentMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PaymentMethod *arg1 = (FIX::PaymentMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PaymentMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PaymentMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PaymentMethod" "', argument " "1"" of type '" "FIX::PaymentMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PaymentMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingLegOptAttribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegOptAttribute *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegOptAttribute")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegOptAttribute *)new FIX::UnderlyingLegOptAttribute();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegOptAttribute, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegOptAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegOptAttribute *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegOptAttribute",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegOptAttribute *)new FIX::UnderlyingLegOptAttribute((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegOptAttribute, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegOptAttribute(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegOptAttribute__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegOptAttribute__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegOptAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegOptAttribute::UnderlyingLegOptAttribute()\n"
    "    FIX::UnderlyingLegOptAttribute::UnderlyingLegOptAttribute(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegOptAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegOptAttribute *arg1 = (FIX::UnderlyingLegOptAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegOptAttribute",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegOptAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegOptAttribute" "', argument " "1"" of type '" "FIX::UnderlyingLegOptAttribute *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegOptAttribute * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LegVolatility__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegVolatility *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegVolatility")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegVolatility *)new FIX::LegVolatility();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegVolatility, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegVolatility__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegVolatility *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegVolatility",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegVolatility" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegVolatility" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegVolatility *)new FIX::LegVolatility((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegVolatility, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegVolatility(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegVolatility__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegVolatility__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegVolatility'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegVolatility::LegVolatility()\n"
    "    FIX::LegVolatility::LegVolatility(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegVolatility(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegVolatility *arg1 = (FIX::LegVolatility *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegVolatility",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegVolatility, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegVolatility" "', argument " "1"" of type '" "FIX::LegVolatility *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegVolatility * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeInstrAttribType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrAttribType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeInstrAttribType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrAttribType *)new FIX::DerivativeInstrAttribType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrAttribType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrAttribType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeInstrAttribType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeInstrAttribType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeInstrAttribType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeInstrAttribType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrAttribType *)new FIX::DerivativeInstrAttribType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrAttribType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrAttribType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeInstrAttribType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrAttribType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeInstrAttribType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeInstrAttribType::DerivativeInstrAttribType()\n"
    "    FIX::DerivativeInstrAttribType::DerivativeInstrAttribType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeInstrAttribType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrAttribType *arg1 = (FIX::DerivativeInstrAttribType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeInstrAttribType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeInstrAttribType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeInstrAttribType" "', argument " "1"" of type '" "FIX::DerivativeInstrAttribType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeInstrAttribType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DerivativeUnitOfMeasureQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeUnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeUnitOfMeasureQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeUnitOfMeasureQty *)new FIX::DerivativeUnitOfMeasureQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeUnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeUnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeUnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeUnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeUnitOfMeasureQty *)new FIX::DerivativeUnitOfMeasureQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeUnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeUnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeUnitOfMeasureQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeUnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeUnitOfMeasureQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeUnitOfMeasureQty::DerivativeUnitOfMeasureQty()\n"
    "    FIX::DerivativeUnitOfMeasureQty::DerivativeUnitOfMeasureQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeUnitOfMeasureQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeUnitOfMeasureQty *arg1 = (FIX::DerivativeUnitOfMeasureQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeUnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeUnitOfMeasureQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::DerivativeUnitOfMeasureQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeUnitOfMeasureQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_NoStatsIndicators__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoStatsIndicators *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoStatsIndicators")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoStatsIndicators *)new FIX::NoStatsIndicators();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoStatsIndicators, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStatsIndicators__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoStatsIndicators *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoStatsIndicators",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoStatsIndicators" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoStatsIndicators" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoStatsIndicators *)new FIX::NoStatsIndicators((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoStatsIndicators, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStatsIndicators(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoStatsIndicators__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoStatsIndicators__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoStatsIndicators'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoStatsIndicators::NoStatsIndicators()\n"
    "    FIX::NoStatsIndicators::NoStatsIndicators(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoStatsIndicators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoStatsIndicators *arg1 = (FIX::NoStatsIndicators *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoStatsIndicators",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoStatsIndicators, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoStatsIndicators" "', argument " "1"" of type '" "FIX::NoStatsIndicators *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoStatsIndicators * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_TriggerPriceTypeScope__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerPriceTypeScope *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerPriceTypeScope")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerPriceTypeScope *)new FIX::TriggerPriceTypeScope();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerPriceTypeScope, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPriceTypeScope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerPriceTypeScope *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerPriceTypeScope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerPriceTypeScope" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerPriceTypeScope" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerPriceTypeScope *)new FIX::TriggerPriceTypeScope((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerPriceTypeScope, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPriceTypeScope(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerPriceTypeScope__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerPriceTypeScope__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerPriceTypeScope'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerPriceTypeScope::TriggerPriceTypeScope()\n"
    "    FIX::TriggerPriceTypeScope::TriggerPriceTypeScope(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerPriceTypeScope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerPriceTypeScope *arg1 = (FIX::TriggerPriceTypeScope *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerPriceTypeScope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerPriceTypeScope, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerPriceTypeScope" "', argument " "1"" of type '" "FIX::TriggerPriceTypeScope *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerPriceTypeScope * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_LastNetworkResponseID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastNetworkResponseID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastNetworkResponseID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastNetworkResponseID *)new FIX::LastNetworkResponseID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastNetworkResponseID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastNetworkResponseID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastNetworkResponseID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastNetworkResponseID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastNetworkResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastNetworkResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastNetworkResponseID *)new FIX::LastNetworkResponseID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastNetworkResponseID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastNetworkResponseID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastNetworkResponseID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastNetworkResponseID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastNetworkResponseID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastNetworkResponseID::LastNetworkResponseID()\n"
    "    FIX::LastNetworkResponseID::LastNetworkResponseID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastNetworkResponseID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastNetworkResponseID *arg1 = (FIX::LastNetworkResponseID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastNetworkResponseID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastNetworkResponseID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastNetworkResponseID" "', argument " "1"" of type '" "FIX::LastNetworkResponseID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastNetworkResponseID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingSettlPriceType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSettlPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSettlPriceType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSettlPriceType *)new FIX::UnderlyingSettlPriceType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSettlPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSettlPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSettlPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSettlPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSettlPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSettlPriceType *)new FIX::UnderlyingSettlPriceType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSettlPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSettlPriceType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSettlPriceType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSettlPriceType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSettlPriceType::UnderlyingSettlPriceType()\n"
    "    FIX::UnderlyingSettlPriceType::UnderlyingSettlPriceType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSettlPriceType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSettlPriceType *arg1 = (FIX::UnderlyingSettlPriceType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSettlPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSettlPriceType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSettlPriceType" "', argument " "1"" of type '" "FIX::UnderlyingSettlPriceType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSettlPriceType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ApplReportID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplReportID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplReportID *)new FIX::ApplReportID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplReportID *)new FIX::ApplReportID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplReportID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplReportID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplReportID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplReportID::ApplReportID()\n"
    "    FIX::ApplReportID::ApplReportID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplReportID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplReportID *arg1 = (FIX::ApplReportID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplReportID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplReportID" "', argument " "1"" of type '" "FIX::ApplReportID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplReportID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_PegLimitType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegLimitType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PegLimitType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegLimitType *)new FIX::PegLimitType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegLimitType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegLimitType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PegLimitType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PegLimitType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PegLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PegLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegLimitType *)new FIX::PegLimitType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegLimitType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegLimitType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PegLimitType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegLimitType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PegLimitType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PegLimitType::PegLimitType()\n"
    "    FIX::PegLimitType::PegLimitType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PegLimitType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegLimitType *arg1 = (FIX::PegLimitType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PegLimitType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PegLimitType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PegLimitType" "', argument " "1"" of type '" "FIX::PegLimitType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PegLimitType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ExecID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExecID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecID *)new FIX::ExecID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExecID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExecID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecID *)new FIX::ExecID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExecID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExecID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExecID::ExecID()\n"
    "    FIX::ExecID::ExecID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExecID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecID *arg1 = (FIX::ExecID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExecID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExecID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExecID" "', argument " "1"" of type '" "FIX::ExecID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExecID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_Side__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Side *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Side")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Side *)new FIX::Side();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Side, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Side__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Side *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Side",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Side" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Side" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Side *)new FIX::Side((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Side, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Side(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Side__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Side__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Side'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Side::Side()\n"
    "    FIX::Side::Side(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Side(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Side *arg1 = (FIX::Side *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Side",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Side, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Side" "', argument " "1"" of type '" "FIX::Side *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Side * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_UnderlyingLastPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLastPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLastPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLastPx *)new FIX::UnderlyingLastPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLastPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLastPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLastPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLastPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLastPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLastPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLastPx *)new FIX::UnderlyingLastPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLastPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLastPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLastPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLastPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLastPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLastPx::UnderlyingLastPx()\n"
    "    FIX::UnderlyingLastPx::UnderlyingLastPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLastPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLastPx *arg1 = (FIX::UnderlyingLastPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLastPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLastPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLastPx" "', argument " "1"" of type '" "FIX::UnderlyingLastPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLastPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MarketDepth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarketDepth *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MarketDepth")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarketDepth *)new FIX::MarketDepth();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarketDepth, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketDepth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MarketDepth *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MarketDepth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarketDepth" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarketDepth" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarketDepth *)new FIX::MarketDepth((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarketDepth, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketDepth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MarketDepth__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarketDepth__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarketDepth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MarketDepth::MarketDepth()\n"
    "    FIX::MarketDepth::MarketDepth(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MarketDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarketDepth *arg1 = (FIX::MarketDepth *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MarketDepth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MarketDepth, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarketDepth" "', argument " "1"" of type '" "FIX::MarketDepth *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MarketDepth * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_DiscretionOffset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionOffset *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DiscretionOffset")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionOffset *)new FIX::DiscretionOffset();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionOffset, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionOffset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DiscretionOffset *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DiscretionOffset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscretionOffset" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretionOffset" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionOffset *)new FIX::DiscretionOffset((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionOffset, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionOffset(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DiscretionOffset__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionOffset__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DiscretionOffset'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DiscretionOffset::DiscretionOffset()\n"
    "    FIX::DiscretionOffset::DiscretionOffset(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DiscretionOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionOffset *arg1 = (FIX::DiscretionOffset *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DiscretionOffset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DiscretionOffset, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscretionOffset" "', argument " "1"" of type '" "FIX::DiscretionOffset *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DiscretionOffset * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_ContAmtType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContAmtType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ContAmtType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContAmtType *)new FIX::ContAmtType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContAmtType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContAmtType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContAmtType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContAmtType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContAmtType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContAmtType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContAmtType *)new FIX::ContAmtType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContAmtType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContAmtType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ContAmtType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContAmtType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContAmtType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ContAmtType::ContAmtType()\n"
    "    FIX::ContAmtType::ContAmtType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ContAmtType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContAmtType *arg1 = (FIX::ContAmtType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContAmtType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ContAmtType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContAmtType" "', argument " "1"" of type '" "FIX::ContAmtType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ContAmtType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_MiscFeeCurr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MiscFeeCurr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MiscFeeCurr")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MiscFeeCurr *)new FIX::MiscFeeCurr();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MiscFeeCurr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeCurr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MiscFeeCurr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MiscFeeCurr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MiscFeeCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MiscFeeCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MiscFeeCurr *)new FIX::MiscFeeCurr((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MiscFeeCurr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeCurr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MiscFeeCurr__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MiscFeeCurr__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MiscFeeCurr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MiscFeeCurr::MiscFeeCurr()\n"
    "    FIX::MiscFeeCurr::MiscFeeCurr(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MiscFeeCurr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MiscFeeCurr *arg1 = (FIX::MiscFeeCurr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MiscFeeCurr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MiscFeeCurr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MiscFeeCurr" "', argument " "1"" of type '" "FIX::MiscFeeCurr *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MiscFeeCurr * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_AttachmentPoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AttachmentPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AttachmentPoint")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AttachmentPoint *)new FIX::AttachmentPoint();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AttachmentPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AttachmentPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AttachmentPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AttachmentPoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AttachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AttachmentPoint" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AttachmentPoint *)new FIX::AttachmentPoint((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AttachmentPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AttachmentPoint(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AttachmentPoint__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AttachmentPoint__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AttachmentPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AttachmentPoint::AttachmentPoint()\n"
    "    FIX::AttachmentPoint::AttachmentPoint(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AttachmentPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AttachmentPoint *arg1 = (FIX::AttachmentPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AttachmentPoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AttachmentPoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AttachmentPoint" "', argument " "1"" of type '" "FIX::AttachmentPoint *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AttachmentPoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


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

SWIGINTERN PyObject *_wrap_new_OrderCategory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderCategory *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrderCategory")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderCategory *)new FIX::OrderCategory();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderCategory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderCategory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrderCategory *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrderCategory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrderCategory" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrderCategory" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderCategory *)new FIX::OrderCategory((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderCategory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderCategory(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrderCategory__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderCategory__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrderCategory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrderCategory::OrderCategory()\n"
    "    FIX::OrderCategory::OrderCategory(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrderCategory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderCategory *arg1 = (FIX::OrderCategory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrderCategory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrderCategory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrderCategory" "', argument " "1"" of type '" "FIX::OrderCategory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrderCategory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrderCategory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrderCategory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AdvTransType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AdvTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AdvTransType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AdvTransType *)new FIX::AdvTransType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AdvTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AdvTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AdvTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AdvTransType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AdvTransType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AdvTransType *)new FIX::AdvTransType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AdvTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AdvTransType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AdvTransType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AdvTransType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AdvTransType::AdvTransType()\n"
    "    FIX::AdvTransType::AdvTransType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AdvTransType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AdvTransType *arg1 = (FIX::AdvTransType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AdvTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AdvTransType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AdvTransType" "', argument " "1"" of type '" "FIX::AdvTransType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AdvTransType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AdvTransType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AdvTransType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_WtAverageLiquidity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::WtAverageLiquidity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_WtAverageLiquidity")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::WtAverageLiquidity *)new FIX::WtAverageLiquidity();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__WtAverageLiquidity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WtAverageLiquidity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::WtAverageLiquidity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_WtAverageLiquidity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WtAverageLiquidity" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_WtAverageLiquidity" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::WtAverageLiquidity *)new FIX::WtAverageLiquidity((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__WtAverageLiquidity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WtAverageLiquidity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_WtAverageLiquidity__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_WtAverageLiquidity__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_WtAverageLiquidity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::WtAverageLiquidity::WtAverageLiquidity()\n"
    "    FIX::WtAverageLiquidity::WtAverageLiquidity(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_WtAverageLiquidity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::WtAverageLiquidity *arg1 = (FIX::WtAverageLiquidity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_WtAverageLiquidity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__WtAverageLiquidity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WtAverageLiquidity" "', argument " "1"" of type '" "FIX::WtAverageLiquidity *""'"); 
  }
  arg1 = reinterpret_cast< FIX::WtAverageLiquidity * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *WtAverageLiquidity_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__WtAverageLiquidity, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_QuoteSetValidUntilTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteSetValidUntilTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteSetValidUntilTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteSetValidUntilTime *)new FIX::QuoteSetValidUntilTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteSetValidUntilTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteSetValidUntilTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteSetValidUntilTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteSetValidUntilTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QuoteSetValidUntilTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteSetValidUntilTime *)new FIX::QuoteSetValidUntilTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteSetValidUntilTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteSetValidUntilTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteSetValidUntilTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteSetValidUntilTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteSetValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteSetValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteSetValidUntilTime *)new FIX::QuoteSetValidUntilTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteSetValidUntilTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteSetValidUntilTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::QuoteSetValidUntilTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_QuoteSetValidUntilTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteSetValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteSetValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_QuoteSetValidUntilTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteSetValidUntilTime *)new FIX::QuoteSetValidUntilTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteSetValidUntilTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteSetValidUntilTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteSetValidUntilTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteSetValidUntilTime__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_QuoteSetValidUntilTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_QuoteSetValidUntilTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteSetValidUntilTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteSetValidUntilTime::QuoteSetValidUntilTime()\n"
    "    FIX::QuoteSetValidUntilTime::QuoteSetValidUntilTime(bool)\n"
    "    FIX::QuoteSetValidUntilTime::QuoteSetValidUntilTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::QuoteSetValidUntilTime::QuoteSetValidUntilTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteSetValidUntilTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteSetValidUntilTime *arg1 = (FIX::QuoteSetValidUntilTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteSetValidUntilTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteSetValidUntilTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteSetValidUntilTime" "', argument " "1"" of type '" "FIX::QuoteSetValidUntilTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteSetValidUntilTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteSetValidUntilTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__QuoteSetValidUntilTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoNested4PartyIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNested4PartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoNested4PartyIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNested4PartyIDs *)new FIX::NoNested4PartyIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNested4PartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested4PartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoNested4PartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoNested4PartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoNested4PartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoNested4PartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNested4PartyIDs *)new FIX::NoNested4PartyIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNested4PartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested4PartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoNested4PartyIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNested4PartyIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoNested4PartyIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoNested4PartyIDs::NoNested4PartyIDs()\n"
    "    FIX::NoNested4PartyIDs::NoNested4PartyIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoNested4PartyIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNested4PartyIDs *arg1 = (FIX::NoNested4PartyIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoNested4PartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoNested4PartyIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoNested4PartyIDs" "', argument " "1"" of type '" "FIX::NoNested4PartyIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoNested4PartyIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoNested4PartyIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoNested4PartyIDs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegPutOrCall__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegPutOrCall *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegPutOrCall")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegPutOrCall *)new FIX::LegPutOrCall();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegPutOrCall, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPutOrCall__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegPutOrCall *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegPutOrCall",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegPutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegPutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegPutOrCall *)new FIX::LegPutOrCall((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegPutOrCall, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPutOrCall(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegPutOrCall__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegPutOrCall__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegPutOrCall'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegPutOrCall::LegPutOrCall()\n"
    "    FIX::LegPutOrCall::LegPutOrCall(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegPutOrCall(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegPutOrCall *arg1 = (FIX::LegPutOrCall *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegPutOrCall",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegPutOrCall, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegPutOrCall" "', argument " "1"" of type '" "FIX::LegPutOrCall *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegPutOrCall * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegPutOrCall_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegPutOrCall, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UserStatusText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UserStatusText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UserStatusText")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UserStatusText *)new FIX::UserStatusText();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UserStatusText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserStatusText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UserStatusText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UserStatusText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UserStatusText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UserStatusText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UserStatusText *)new FIX::UserStatusText((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UserStatusText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserStatusText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UserStatusText__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UserStatusText__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UserStatusText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UserStatusText::UserStatusText()\n"
    "    FIX::UserStatusText::UserStatusText(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UserStatusText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UserStatusText *arg1 = (FIX::UserStatusText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UserStatusText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UserStatusText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UserStatusText" "', argument " "1"" of type '" "FIX::UserStatusText *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UserStatusText * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UserStatusText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UserStatusText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Nested2PartySubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested2PartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested2PartySubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested2PartySubID *)new FIX::Nested2PartySubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested2PartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested2PartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested2PartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested2PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested2PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested2PartySubID *)new FIX::Nested2PartySubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested2PartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested2PartySubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested2PartySubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested2PartySubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested2PartySubID::Nested2PartySubID()\n"
    "    FIX::Nested2PartySubID::Nested2PartySubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested2PartySubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested2PartySubID *arg1 = (FIX::Nested2PartySubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested2PartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested2PartySubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested2PartySubID" "', argument " "1"" of type '" "FIX::Nested2PartySubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested2PartySubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Nested2PartySubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Nested2PartySubID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EFPTrackingError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EFPTrackingError *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EFPTrackingError")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EFPTrackingError *)new FIX::EFPTrackingError();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EFPTrackingError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EFPTrackingError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EFPTrackingError *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EFPTrackingError",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EFPTrackingError" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EFPTrackingError" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EFPTrackingError *)new FIX::EFPTrackingError((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EFPTrackingError, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EFPTrackingError(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EFPTrackingError__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EFPTrackingError__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EFPTrackingError'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EFPTrackingError::EFPTrackingError()\n"
    "    FIX::EFPTrackingError::EFPTrackingError(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EFPTrackingError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EFPTrackingError *arg1 = (FIX::EFPTrackingError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EFPTrackingError",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EFPTrackingError, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EFPTrackingError" "', argument " "1"" of type '" "FIX::EFPTrackingError *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EFPTrackingError * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EFPTrackingError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EFPTrackingError, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SideLiquidityInd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideLiquidityInd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideLiquidityInd")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideLiquidityInd *)new FIX::SideLiquidityInd();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideLiquidityInd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideLiquidityInd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideLiquidityInd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideLiquidityInd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideLiquidityInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideLiquidityInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideLiquidityInd *)new FIX::SideLiquidityInd((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideLiquidityInd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideLiquidityInd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideLiquidityInd__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideLiquidityInd__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideLiquidityInd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideLiquidityInd::SideLiquidityInd()\n"
    "    FIX::SideLiquidityInd::SideLiquidityInd(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideLiquidityInd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideLiquidityInd *arg1 = (FIX::SideLiquidityInd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideLiquidityInd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideLiquidityInd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideLiquidityInd" "', argument " "1"" of type '" "FIX::SideLiquidityInd *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideLiquidityInd * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SideLiquidityInd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SideLiquidityInd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeMinPriceIncrement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeMinPriceIncrement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeMinPriceIncrement")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeMinPriceIncrement *)new FIX::DerivativeMinPriceIncrement();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeMinPriceIncrement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMinPriceIncrement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeMinPriceIncrement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeMinPriceIncrement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeMinPriceIncrement" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeMinPriceIncrement" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeMinPriceIncrement *)new FIX::DerivativeMinPriceIncrement((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeMinPriceIncrement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMinPriceIncrement(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeMinPriceIncrement__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeMinPriceIncrement__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeMinPriceIncrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeMinPriceIncrement::DerivativeMinPriceIncrement()\n"
    "    FIX::DerivativeMinPriceIncrement::DerivativeMinPriceIncrement(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeMinPriceIncrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeMinPriceIncrement *arg1 = (FIX::DerivativeMinPriceIncrement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeMinPriceIncrement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeMinPriceIncrement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeMinPriceIncrement" "', argument " "1"" of type '" "FIX::DerivativeMinPriceIncrement *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeMinPriceIncrement * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeMinPriceIncrement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeMinPriceIncrement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PublishTrdIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PublishTrdIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PublishTrdIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PublishTrdIndicator *)new FIX::PublishTrdIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PublishTrdIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PublishTrdIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PublishTrdIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PublishTrdIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PublishTrdIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PublishTrdIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PublishTrdIndicator *)new FIX::PublishTrdIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PublishTrdIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PublishTrdIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PublishTrdIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PublishTrdIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PublishTrdIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PublishTrdIndicator::PublishTrdIndicator()\n"
    "    FIX::PublishTrdIndicator::PublishTrdIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PublishTrdIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PublishTrdIndicator *arg1 = (FIX::PublishTrdIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PublishTrdIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PublishTrdIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PublishTrdIndicator" "', argument " "1"" of type '" "FIX::PublishTrdIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PublishTrdIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PublishTrdIndicator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PublishTrdIndicator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_InvestorCountryOfResidence__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvestorCountryOfResidence *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InvestorCountryOfResidence")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InvestorCountryOfResidence *)new FIX::InvestorCountryOfResidence();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InvestorCountryOfResidence, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvestorCountryOfResidence__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::COUNTRY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InvestorCountryOfResidence *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InvestorCountryOfResidence",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__COUNTRY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InvestorCountryOfResidence" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InvestorCountryOfResidence" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::COUNTRY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InvestorCountryOfResidence *)new FIX::InvestorCountryOfResidence((FIX::COUNTRY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InvestorCountryOfResidence, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InvestorCountryOfResidence(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InvestorCountryOfResidence__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__COUNTRY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InvestorCountryOfResidence__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InvestorCountryOfResidence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InvestorCountryOfResidence::InvestorCountryOfResidence()\n"
    "    FIX::InvestorCountryOfResidence::InvestorCountryOfResidence(FIX::COUNTRY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InvestorCountryOfResidence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InvestorCountryOfResidence *arg1 = (FIX::InvestorCountryOfResidence *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InvestorCountryOfResidence",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InvestorCountryOfResidence, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InvestorCountryOfResidence" "', argument " "1"" of type '" "FIX::InvestorCountryOfResidence *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InvestorCountryOfResidence * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InvestorCountryOfResidence_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__InvestorCountryOfResidence, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SideReasonCd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideReasonCd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideReasonCd")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideReasonCd *)new FIX::SideReasonCd();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideReasonCd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideReasonCd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideReasonCd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideReasonCd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideReasonCd" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideReasonCd" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideReasonCd *)new FIX::SideReasonCd((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideReasonCd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideReasonCd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideReasonCd__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideReasonCd__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideReasonCd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideReasonCd::SideReasonCd()\n"
    "    FIX::SideReasonCd::SideReasonCd(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideReasonCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideReasonCd *arg1 = (FIX::SideReasonCd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideReasonCd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideReasonCd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideReasonCd" "', argument " "1"" of type '" "FIX::SideReasonCd *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideReasonCd * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SideReasonCd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SideReasonCd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MinPriceIncrement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinPriceIncrement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MinPriceIncrement")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MinPriceIncrement *)new FIX::MinPriceIncrement();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MinPriceIncrement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinPriceIncrement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MinPriceIncrement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MinPriceIncrement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MinPriceIncrement" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MinPriceIncrement" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MinPriceIncrement *)new FIX::MinPriceIncrement((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MinPriceIncrement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinPriceIncrement(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MinPriceIncrement__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinPriceIncrement__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MinPriceIncrement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MinPriceIncrement::MinPriceIncrement()\n"
    "    FIX::MinPriceIncrement::MinPriceIncrement(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MinPriceIncrement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinPriceIncrement *arg1 = (FIX::MinPriceIncrement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MinPriceIncrement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MinPriceIncrement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MinPriceIncrement" "', argument " "1"" of type '" "FIX::MinPriceIncrement *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MinPriceIncrement * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MinPriceIncrement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MinPriceIncrement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentContactName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecuritySettlAgentContactName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecuritySettlAgentContactName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecuritySettlAgentContactName *)new FIX::SecuritySettlAgentContactName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecuritySettlAgentContactName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentContactName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecuritySettlAgentContactName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecuritySettlAgentContactName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecuritySettlAgentContactName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecuritySettlAgentContactName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecuritySettlAgentContactName *)new FIX::SecuritySettlAgentContactName((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecuritySettlAgentContactName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentContactName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecuritySettlAgentContactName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecuritySettlAgentContactName__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecuritySettlAgentContactName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecuritySettlAgentContactName::SecuritySettlAgentContactName()\n"
    "    FIX::SecuritySettlAgentContactName::SecuritySettlAgentContactName(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecuritySettlAgentContactName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecuritySettlAgentContactName *arg1 = (FIX::SecuritySettlAgentContactName *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecuritySettlAgentContactName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecuritySettlAgentContactName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecuritySettlAgentContactName" "', argument " "1"" of type '" "FIX::SecuritySettlAgentContactName *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecuritySettlAgentContactName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecuritySettlAgentContactName_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecuritySettlAgentContactName, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityResponseType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityResponseType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityResponseType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityResponseType *)new FIX::SecurityResponseType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityResponseType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityResponseType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityResponseType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityResponseType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityResponseType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityResponseType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityResponseType *)new FIX::SecurityResponseType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityResponseType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityResponseType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityResponseType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityResponseType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityResponseType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityResponseType::SecurityResponseType()\n"
    "    FIX::SecurityResponseType::SecurityResponseType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityResponseType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityResponseType *arg1 = (FIX::SecurityResponseType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityResponseType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityResponseType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityResponseType" "', argument " "1"" of type '" "FIX::SecurityResponseType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityResponseType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityResponseType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityResponseType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurvePoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegBenchmarkCurvePoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegBenchmarkCurvePoint")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegBenchmarkCurvePoint *)new FIX::LegBenchmarkCurvePoint();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegBenchmarkCurvePoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurvePoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegBenchmarkCurvePoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegBenchmarkCurvePoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegBenchmarkCurvePoint" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegBenchmarkCurvePoint" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegBenchmarkCurvePoint *)new FIX::LegBenchmarkCurvePoint((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegBenchmarkCurvePoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurvePoint(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegBenchmarkCurvePoint__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegBenchmarkCurvePoint__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegBenchmarkCurvePoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegBenchmarkCurvePoint::LegBenchmarkCurvePoint()\n"
    "    FIX::LegBenchmarkCurvePoint::LegBenchmarkCurvePoint(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegBenchmarkCurvePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegBenchmarkCurvePoint *arg1 = (FIX::LegBenchmarkCurvePoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegBenchmarkCurvePoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegBenchmarkCurvePoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegBenchmarkCurvePoint" "', argument " "1"" of type '" "FIX::LegBenchmarkCurvePoint *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegBenchmarkCurvePoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegBenchmarkCurvePoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegBenchmarkCurvePoint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ClearingFirm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClearingFirm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ClearingFirm")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClearingFirm *)new FIX::ClearingFirm();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClearingFirm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingFirm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ClearingFirm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ClearingFirm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClearingFirm" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ClearingFirm" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClearingFirm *)new FIX::ClearingFirm((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClearingFirm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingFirm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ClearingFirm__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClearingFirm__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ClearingFirm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ClearingFirm::ClearingFirm()\n"
    "    FIX::ClearingFirm::ClearingFirm(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ClearingFirm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClearingFirm *arg1 = (FIX::ClearingFirm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ClearingFirm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ClearingFirm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClearingFirm" "', argument " "1"" of type '" "FIX::ClearingFirm *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ClearingFirm * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ClearingFirm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ClearingFirm, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SessionStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SessionStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SessionStatus *)new FIX::SessionStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SessionStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SessionStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SessionStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SessionStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SessionStatus *)new FIX::SessionStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SessionStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SessionStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SessionStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SessionStatus::SessionStatus()\n"
    "    FIX::SessionStatus::SessionStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SessionStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionStatus *arg1 = (FIX::SessionStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SessionStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SessionStatus" "', argument " "1"" of type '" "FIX::SessionStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SessionStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SessionStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TriggerSecurityID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerSecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerSecurityID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerSecurityID *)new FIX::TriggerSecurityID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerSecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerSecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerSecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerSecurityID *)new FIX::TriggerSecurityID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerSecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerSecurityID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerSecurityID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerSecurityID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerSecurityID::TriggerSecurityID()\n"
    "    FIX::TriggerSecurityID::TriggerSecurityID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerSecurityID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerSecurityID *arg1 = (FIX::TriggerSecurityID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerSecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerSecurityID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerSecurityID" "', argument " "1"" of type '" "FIX::TriggerSecurityID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerSecurityID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TriggerSecurityID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TriggerSecurityID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TotNoAllocs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoAllocs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotNoAllocs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoAllocs *)new FIX::TotNoAllocs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoAllocs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoAllocs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotNoAllocs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotNoAllocs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotNoAllocs" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotNoAllocs" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoAllocs *)new FIX::TotNoAllocs((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoAllocs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoAllocs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotNoAllocs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoAllocs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotNoAllocs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotNoAllocs::TotNoAllocs()\n"
    "    FIX::TotNoAllocs::TotNoAllocs(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotNoAllocs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoAllocs *arg1 = (FIX::TotNoAllocs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotNoAllocs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotNoAllocs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotNoAllocs" "', argument " "1"" of type '" "FIX::TotNoAllocs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotNoAllocs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TotNoAllocs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TotNoAllocs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoAltMDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoAltMDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoAltMDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoAltMDSource *)new FIX::NoAltMDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoAltMDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAltMDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoAltMDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoAltMDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoAltMDSource" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoAltMDSource" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoAltMDSource *)new FIX::NoAltMDSource((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoAltMDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAltMDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoAltMDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoAltMDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoAltMDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoAltMDSource::NoAltMDSource()\n"
    "    FIX::NoAltMDSource::NoAltMDSource(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoAltMDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoAltMDSource *arg1 = (FIX::NoAltMDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoAltMDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoAltMDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoAltMDSource" "', argument " "1"" of type '" "FIX::NoAltMDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoAltMDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoAltMDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoAltMDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocAccountType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocAccountType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocAccountType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocAccountType *)new FIX::AllocAccountType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocAccountType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAccountType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocAccountType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocAccountType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocAccountType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocAccountType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocAccountType *)new FIX::AllocAccountType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocAccountType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAccountType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocAccountType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocAccountType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocAccountType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocAccountType::AllocAccountType()\n"
    "    FIX::AllocAccountType::AllocAccountType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocAccountType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocAccountType *arg1 = (FIX::AllocAccountType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocAccountType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocAccountType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocAccountType" "', argument " "1"" of type '" "FIX::AllocAccountType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocAccountType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocAccountType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocAccountType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LastPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastPx *)new FIX::LastPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastPx *)new FIX::LastPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastPx::LastPx()\n"
    "    FIX::LastPx::LastPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastPx *arg1 = (FIX::LastPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastPx" "', argument " "1"" of type '" "FIX::LastPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LastPx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LastPx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocTransType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocTransType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocTransType *)new FIX::AllocTransType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocTransType *)new FIX::AllocTransType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocTransType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocTransType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocTransType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocTransType::AllocTransType()\n"
    "    FIX::AllocTransType::AllocTransType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocTransType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocTransType *arg1 = (FIX::AllocTransType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocTransType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocTransType" "', argument " "1"" of type '" "FIX::AllocTransType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocTransType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocTransType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocTransType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TotNoQuoteEntries__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoQuoteEntries *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotNoQuoteEntries")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoQuoteEntries *)new FIX::TotNoQuoteEntries();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoQuoteEntries, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoQuoteEntries__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotNoQuoteEntries *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotNoQuoteEntries",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotNoQuoteEntries" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotNoQuoteEntries" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoQuoteEntries *)new FIX::TotNoQuoteEntries((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoQuoteEntries, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoQuoteEntries(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotNoQuoteEntries__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoQuoteEntries__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotNoQuoteEntries'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotNoQuoteEntries::TotNoQuoteEntries()\n"
    "    FIX::TotNoQuoteEntries::TotNoQuoteEntries(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotNoQuoteEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoQuoteEntries *arg1 = (FIX::TotNoQuoteEntries *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotNoQuoteEntries",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotNoQuoteEntries, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotNoQuoteEntries" "', argument " "1"" of type '" "FIX::TotNoQuoteEntries *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotNoQuoteEntries * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TotNoQuoteEntries_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TotNoQuoteEntries, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MinBidSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinBidSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MinBidSize")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MinBidSize *)new FIX::MinBidSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MinBidSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinBidSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MinBidSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MinBidSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MinBidSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MinBidSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MinBidSize *)new FIX::MinBidSize((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MinBidSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinBidSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MinBidSize__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinBidSize__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MinBidSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MinBidSize::MinBidSize()\n"
    "    FIX::MinBidSize::MinBidSize(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MinBidSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinBidSize *arg1 = (FIX::MinBidSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MinBidSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MinBidSize, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MinBidSize" "', argument " "1"" of type '" "FIX::MinBidSize *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MinBidSize * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MinBidSize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MinBidSize, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlBrkrCode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlBrkrCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlBrkrCode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlBrkrCode *)new FIX::SettlBrkrCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlBrkrCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlBrkrCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlBrkrCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlBrkrCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlBrkrCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlBrkrCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlBrkrCode *)new FIX::SettlBrkrCode((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlBrkrCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlBrkrCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlBrkrCode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlBrkrCode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlBrkrCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlBrkrCode::SettlBrkrCode()\n"
    "    FIX::SettlBrkrCode::SettlBrkrCode(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlBrkrCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlBrkrCode *arg1 = (FIX::SettlBrkrCode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlBrkrCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlBrkrCode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlBrkrCode" "', argument " "1"" of type '" "FIX::SettlBrkrCode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlBrkrCode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlBrkrCode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlBrkrCode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CardHolderName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CardHolderName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CardHolderName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CardHolderName *)new FIX::CardHolderName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CardHolderName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardHolderName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CardHolderName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CardHolderName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CardHolderName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CardHolderName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CardHolderName *)new FIX::CardHolderName((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CardHolderName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardHolderName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CardHolderName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CardHolderName__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CardHolderName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CardHolderName::CardHolderName()\n"
    "    FIX::CardHolderName::CardHolderName(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CardHolderName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CardHolderName *arg1 = (FIX::CardHolderName *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CardHolderName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CardHolderName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CardHolderName" "', argument " "1"" of type '" "FIX::CardHolderName *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CardHolderName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CardHolderName_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CardHolderName, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExpirationQtyType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExpirationQtyType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExpirationQtyType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExpirationQtyType *)new FIX::ExpirationQtyType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExpirationQtyType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpirationQtyType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExpirationQtyType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExpirationQtyType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExpirationQtyType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExpirationQtyType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExpirationQtyType *)new FIX::ExpirationQtyType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExpirationQtyType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpirationQtyType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExpirationQtyType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExpirationQtyType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExpirationQtyType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExpirationQtyType::ExpirationQtyType()\n"
    "    FIX::ExpirationQtyType::ExpirationQtyType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExpirationQtyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExpirationQtyType *arg1 = (FIX::ExpirationQtyType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExpirationQtyType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExpirationQtyType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExpirationQtyType" "', argument " "1"" of type '" "FIX::ExpirationQtyType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExpirationQtyType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExpirationQtyType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ExpirationQtyType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingSecurityDescLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedUnderlyingSecurityDescLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedUnderlyingSecurityDescLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedUnderlyingSecurityDescLen *)new FIX::EncodedUnderlyingSecurityDescLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDescLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingSecurityDescLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedUnderlyingSecurityDescLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedUnderlyingSecurityDescLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedUnderlyingSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedUnderlyingSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedUnderlyingSecurityDescLen *)new FIX::EncodedUnderlyingSecurityDescLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDescLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingSecurityDescLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedUnderlyingSecurityDescLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedUnderlyingSecurityDescLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedUnderlyingSecurityDescLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedUnderlyingSecurityDescLen::EncodedUnderlyingSecurityDescLen()\n"
    "    FIX::EncodedUnderlyingSecurityDescLen::EncodedUnderlyingSecurityDescLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedUnderlyingSecurityDescLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedUnderlyingSecurityDescLen *arg1 = (FIX::EncodedUnderlyingSecurityDescLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedUnderlyingSecurityDescLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDescLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedUnderlyingSecurityDescLen" "', argument " "1"" of type '" "FIX::EncodedUnderlyingSecurityDescLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedUnderlyingSecurityDescLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncodedUnderlyingSecurityDescLen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedUnderlyingSecurityDescLen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_QuoteReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteReqID *)new FIX::QuoteReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteReqID *)new FIX::QuoteReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteReqID::QuoteReqID()\n"
    "    FIX::QuoteReqID::QuoteReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteReqID *arg1 = (FIX::QuoteReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteReqID" "', argument " "1"" of type '" "FIX::QuoteReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteReqID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__QuoteReqID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PriceUnitOfMeasure__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceUnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PriceUnitOfMeasure")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceUnitOfMeasure *)new FIX::PriceUnitOfMeasure();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceUnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceUnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PriceUnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PriceUnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceUnitOfMeasure *)new FIX::PriceUnitOfMeasure((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceUnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceUnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PriceUnitOfMeasure__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceUnitOfMeasure__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PriceUnitOfMeasure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PriceUnitOfMeasure::PriceUnitOfMeasure()\n"
    "    FIX::PriceUnitOfMeasure::PriceUnitOfMeasure(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PriceUnitOfMeasure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceUnitOfMeasure *arg1 = (FIX::PriceUnitOfMeasure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PriceUnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PriceUnitOfMeasure, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::PriceUnitOfMeasure *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PriceUnitOfMeasure * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PriceUnitOfMeasure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PriceUnitOfMeasure, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TZTransactTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTransactTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TZTransactTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TZTransactTime *)new FIX::TZTransactTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TZTransactTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TZTransactTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TZTransactTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TZTransactTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__TZTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TZTransactTime" "', argument " "1"" of type '" "FIX::TZTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TZTransactTime" "', argument " "1"" of type '" "FIX::TZTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TZTransactTime *)new FIX::TZTransactTime((FIX::TZTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TZTransactTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TZTransactTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TZTransactTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__TZTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TZTransactTime__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TZTransactTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TZTransactTime::TZTransactTime()\n"
    "    FIX::TZTransactTime::TZTransactTime(FIX::TZTIMESTAMP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TZTransactTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTransactTime *arg1 = (FIX::TZTransactTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TZTransactTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TZTransactTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TZTransactTime" "', argument " "1"" of type '" "FIX::TZTransactTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TZTransactTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TZTransactTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TZTransactTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocHandlInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocHandlInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocHandlInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocHandlInst *)new FIX::AllocHandlInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocHandlInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocHandlInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocHandlInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocHandlInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocHandlInst" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocHandlInst" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocHandlInst *)new FIX::AllocHandlInst((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocHandlInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocHandlInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocHandlInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocHandlInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocHandlInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocHandlInst::AllocHandlInst()\n"
    "    FIX::AllocHandlInst::AllocHandlInst(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocHandlInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocHandlInst *arg1 = (FIX::AllocHandlInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocHandlInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocHandlInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocHandlInst" "', argument " "1"" of type '" "FIX::AllocHandlInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocHandlInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocHandlInst_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocHandlInst, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingInstrumentPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingInstrumentPartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingInstrumentPartyIDSource *)new FIX::UnderlyingInstrumentPartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingInstrumentPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingInstrumentPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingInstrumentPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingInstrumentPartyIDSource *)new FIX::UnderlyingInstrumentPartyIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingInstrumentPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingInstrumentPartyIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingInstrumentPartyIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingInstrumentPartyIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingInstrumentPartyIDSource::UnderlyingInstrumentPartyIDSource()\n"
    "    FIX::UnderlyingInstrumentPartyIDSource::UnderlyingInstrumentPartyIDSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingInstrumentPartyIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingInstrumentPartyIDSource *arg1 = (FIX::UnderlyingInstrumentPartyIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingInstrumentPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingInstrumentPartyIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::UnderlyingInstrumentPartyIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingInstrumentPartyIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingInstrumentPartyIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingInstrumentPartyIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CurrencyRatio__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CurrencyRatio *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CurrencyRatio")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CurrencyRatio *)new FIX::CurrencyRatio();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CurrencyRatio, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CurrencyRatio__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CurrencyRatio *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CurrencyRatio",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CurrencyRatio" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CurrencyRatio" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CurrencyRatio *)new FIX::CurrencyRatio((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CurrencyRatio, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CurrencyRatio(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CurrencyRatio__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CurrencyRatio__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CurrencyRatio'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CurrencyRatio::CurrencyRatio()\n"
    "    FIX::CurrencyRatio::CurrencyRatio(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CurrencyRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CurrencyRatio *arg1 = (FIX::CurrencyRatio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CurrencyRatio",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CurrencyRatio, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CurrencyRatio" "', argument " "1"" of type '" "FIX::CurrencyRatio *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CurrencyRatio * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CurrencyRatio_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CurrencyRatio, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RefreshQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefreshQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefreshQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefreshQty *)new FIX::RefreshQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefreshQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefreshQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefreshQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefreshQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefreshQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefreshQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefreshQty *)new FIX::RefreshQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefreshQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefreshQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefreshQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefreshQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefreshQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefreshQty::RefreshQty()\n"
    "    FIX::RefreshQty::RefreshQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefreshQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefreshQty *arg1 = (FIX::RefreshQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefreshQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefreshQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefreshQty" "', argument " "1"" of type '" "FIX::RefreshQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefreshQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RefreshQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RefreshQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradeRequestStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeRequestStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeRequestStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeRequestStatus *)new FIX::TradeRequestStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeRequestStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeRequestStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeRequestStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeRequestStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeRequestStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeRequestStatus *)new FIX::TradeRequestStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeRequestStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeRequestStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeRequestStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeRequestStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeRequestStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeRequestStatus::TradeRequestStatus()\n"
    "    FIX::TradeRequestStatus::TradeRequestStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeRequestStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeRequestStatus *arg1 = (FIX::TradeRequestStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeRequestStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeRequestStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeRequestStatus" "', argument " "1"" of type '" "FIX::TradeRequestStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeRequestStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradeRequestStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradeRequestStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TrdRepIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdRepIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TrdRepIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdRepIndicator *)new FIX::TrdRepIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdRepIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRepIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TrdRepIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TrdRepIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrdRepIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TrdRepIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdRepIndicator *)new FIX::TrdRepIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdRepIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRepIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TrdRepIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdRepIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TrdRepIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TrdRepIndicator::TrdRepIndicator()\n"
    "    FIX::TrdRepIndicator::TrdRepIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TrdRepIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdRepIndicator *arg1 = (FIX::TrdRepIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TrdRepIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TrdRepIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrdRepIndicator" "', argument " "1"" of type '" "FIX::TrdRepIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TrdRepIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TrdRepIndicator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TrdRepIndicator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MiscFeeAmt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MiscFeeAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MiscFeeAmt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MiscFeeAmt *)new FIX::MiscFeeAmt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MiscFeeAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MiscFeeAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MiscFeeAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MiscFeeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MiscFeeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MiscFeeAmt *)new FIX::MiscFeeAmt((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MiscFeeAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MiscFeeAmt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MiscFeeAmt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MiscFeeAmt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MiscFeeAmt::MiscFeeAmt()\n"
    "    FIX::MiscFeeAmt::MiscFeeAmt(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MiscFeeAmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MiscFeeAmt *arg1 = (FIX::MiscFeeAmt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MiscFeeAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MiscFeeAmt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MiscFeeAmt" "', argument " "1"" of type '" "FIX::MiscFeeAmt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MiscFeeAmt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MiscFeeAmt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MiscFeeAmt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradSesOpenTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesOpenTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradSesOpenTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesOpenTime *)new FIX::TradSesOpenTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesOpenTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesOpenTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesOpenTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesOpenTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TradSesOpenTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesOpenTime *)new FIX::TradSesOpenTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesOpenTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesOpenTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesOpenTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesOpenTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesOpenTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesOpenTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesOpenTime *)new FIX::TradSesOpenTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesOpenTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesOpenTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::TradSesOpenTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TradSesOpenTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesOpenTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesOpenTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TradSesOpenTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesOpenTime *)new FIX::TradSesOpenTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesOpenTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesOpenTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradSesOpenTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesOpenTime__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_TradSesOpenTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TradSesOpenTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradSesOpenTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradSesOpenTime::TradSesOpenTime()\n"
    "    FIX::TradSesOpenTime::TradSesOpenTime(bool)\n"
    "    FIX::TradSesOpenTime::TradSesOpenTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::TradSesOpenTime::TradSesOpenTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradSesOpenTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesOpenTime *arg1 = (FIX::TradSesOpenTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradSesOpenTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradSesOpenTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradSesOpenTime" "', argument " "1"" of type '" "FIX::TradSesOpenTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradSesOpenTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradSesOpenTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradSesOpenTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PreallocMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PreallocMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PreallocMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PreallocMethod *)new FIX::PreallocMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PreallocMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PreallocMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PreallocMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PreallocMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PreallocMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PreallocMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PreallocMethod *)new FIX::PreallocMethod((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PreallocMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PreallocMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PreallocMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PreallocMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PreallocMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PreallocMethod::PreallocMethod()\n"
    "    FIX::PreallocMethod::PreallocMethod(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PreallocMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PreallocMethod *arg1 = (FIX::PreallocMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PreallocMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PreallocMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PreallocMethod" "', argument " "1"" of type '" "FIX::PreallocMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PreallocMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PreallocMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PreallocMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TaxAdvantageType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TaxAdvantageType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TaxAdvantageType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TaxAdvantageType *)new FIX::TaxAdvantageType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TaxAdvantageType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TaxAdvantageType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TaxAdvantageType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TaxAdvantageType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TaxAdvantageType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TaxAdvantageType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TaxAdvantageType *)new FIX::TaxAdvantageType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TaxAdvantageType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TaxAdvantageType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TaxAdvantageType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TaxAdvantageType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TaxAdvantageType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TaxAdvantageType::TaxAdvantageType()\n"
    "    FIX::TaxAdvantageType::TaxAdvantageType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TaxAdvantageType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TaxAdvantageType *arg1 = (FIX::TaxAdvantageType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TaxAdvantageType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TaxAdvantageType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TaxAdvantageType" "', argument " "1"" of type '" "FIX::TaxAdvantageType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TaxAdvantageType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TaxAdvantageType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TaxAdvantageType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MessageEncoding__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageEncoding *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MessageEncoding")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MessageEncoding *)new FIX::MessageEncoding();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageEncoding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MessageEncoding__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MessageEncoding *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MessageEncoding",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MessageEncoding" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MessageEncoding" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MessageEncoding *)new FIX::MessageEncoding((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageEncoding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MessageEncoding(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MessageEncoding__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MessageEncoding__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MessageEncoding'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MessageEncoding::MessageEncoding()\n"
    "    FIX::MessageEncoding::MessageEncoding(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MessageEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageEncoding *arg1 = (FIX::MessageEncoding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MessageEncoding",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageEncoding, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageEncoding" "', argument " "1"" of type '" "FIX::MessageEncoding *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageEncoding * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MessageEncoding_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MessageEncoding, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoPartySubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoPartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoPartySubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPartySubIDs *)new FIX::NoPartySubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoPartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoPartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPartySubIDs *)new FIX::NoPartySubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoPartySubIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoPartySubIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoPartySubIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoPartySubIDs::NoPartySubIDs()\n"
    "    FIX::NoPartySubIDs::NoPartySubIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoPartySubIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoPartySubIDs *arg1 = (FIX::NoPartySubIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoPartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoPartySubIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoPartySubIDs" "', argument " "1"" of type '" "FIX::NoPartySubIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoPartySubIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoPartySubIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoPartySubIDs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlInstReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlInstReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstReqID *)new FIX::SettlInstReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlInstReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlInstReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlInstReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlInstReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstReqID *)new FIX::SettlInstReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlInstReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlInstReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlInstReqID::SettlInstReqID()\n"
    "    FIX::SettlInstReqID::SettlInstReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlInstReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstReqID *arg1 = (FIX::SettlInstReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlInstReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlInstReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlInstReqID" "', argument " "1"" of type '" "FIX::SettlInstReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlInstReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlInstReqID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlInstReqID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegRepoCollateralSecurityType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegRepoCollateralSecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegRepoCollateralSecurityType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegRepoCollateralSecurityType *)new FIX::LegRepoCollateralSecurityType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegRepoCollateralSecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRepoCollateralSecurityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegRepoCollateralSecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegRepoCollateralSecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegRepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegRepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegRepoCollateralSecurityType *)new FIX::LegRepoCollateralSecurityType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegRepoCollateralSecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRepoCollateralSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegRepoCollateralSecurityType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegRepoCollateralSecurityType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegRepoCollateralSecurityType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegRepoCollateralSecurityType::LegRepoCollateralSecurityType()\n"
    "    FIX::LegRepoCollateralSecurityType::LegRepoCollateralSecurityType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegRepoCollateralSecurityType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegRepoCollateralSecurityType *arg1 = (FIX::LegRepoCollateralSecurityType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegRepoCollateralSecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegRepoCollateralSecurityType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegRepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::LegRepoCollateralSecurityType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegRepoCollateralSecurityType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegRepoCollateralSecurityType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegRepoCollateralSecurityType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AffectedSecondaryOrderID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AffectedSecondaryOrderID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AffectedSecondaryOrderID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AffectedSecondaryOrderID *)new FIX::AffectedSecondaryOrderID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AffectedSecondaryOrderID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AffectedSecondaryOrderID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AffectedSecondaryOrderID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AffectedSecondaryOrderID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AffectedSecondaryOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AffectedSecondaryOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AffectedSecondaryOrderID *)new FIX::AffectedSecondaryOrderID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AffectedSecondaryOrderID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AffectedSecondaryOrderID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AffectedSecondaryOrderID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AffectedSecondaryOrderID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AffectedSecondaryOrderID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AffectedSecondaryOrderID::AffectedSecondaryOrderID()\n"
    "    FIX::AffectedSecondaryOrderID::AffectedSecondaryOrderID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AffectedSecondaryOrderID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AffectedSecondaryOrderID *arg1 = (FIX::AffectedSecondaryOrderID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AffectedSecondaryOrderID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AffectedSecondaryOrderID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AffectedSecondaryOrderID" "', argument " "1"" of type '" "FIX::AffectedSecondaryOrderID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AffectedSecondaryOrderID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AffectedSecondaryOrderID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AffectedSecondaryOrderID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeMaturityTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeMaturityTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeMaturityTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeMaturityTime *)new FIX::DerivativeMaturityTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeMaturityTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMaturityTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTIMEONLY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeMaturityTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeMaturityTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__TZTIMEONLY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMEONLY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeMaturityTime *)new FIX::DerivativeMaturityTime((FIX::TZTIMEONLY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeMaturityTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMaturityTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeMaturityTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__TZTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeMaturityTime__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeMaturityTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeMaturityTime::DerivativeMaturityTime()\n"
    "    FIX::DerivativeMaturityTime::DerivativeMaturityTime(FIX::TZTIMEONLY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeMaturityTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeMaturityTime *arg1 = (FIX::DerivativeMaturityTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeMaturityTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeMaturityTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeMaturityTime" "', argument " "1"" of type '" "FIX::DerivativeMaturityTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeMaturityTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeMaturityTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeMaturityTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExpireTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExpireTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExpireTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExpireTime *)new FIX::ExpireTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExpireTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpireTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExpireTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExpireTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExpireTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExpireTime *)new FIX::ExpireTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExpireTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpireTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExpireTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExpireTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExpireTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExpireTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExpireTime *)new FIX::ExpireTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExpireTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpireTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::ExpireTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ExpireTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExpireTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExpireTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExpireTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExpireTime *)new FIX::ExpireTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExpireTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpireTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExpireTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExpireTime__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_ExpireTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ExpireTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExpireTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExpireTime::ExpireTime()\n"
    "    FIX::ExpireTime::ExpireTime(bool)\n"
    "    FIX::ExpireTime::ExpireTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::ExpireTime::ExpireTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExpireTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExpireTime *arg1 = (FIX::ExpireTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExpireTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExpireTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExpireTime" "', argument " "1"" of type '" "FIX::ExpireTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExpireTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExpireTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ExpireTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingFactor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingFactor *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingFactor")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingFactor *)new FIX::UnderlyingFactor();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingFactor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFactor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingFactor *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingFactor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingFactor" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingFactor" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingFactor *)new FIX::UnderlyingFactor((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingFactor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFactor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingFactor__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingFactor__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingFactor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingFactor::UnderlyingFactor()\n"
    "    FIX::UnderlyingFactor::UnderlyingFactor(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingFactor *arg1 = (FIX::UnderlyingFactor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingFactor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingFactor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingFactor" "', argument " "1"" of type '" "FIX::UnderlyingFactor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingFactor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingFactor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingFactor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OrigOrdModTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigOrdModTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrigOrdModTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigOrdModTime *)new FIX::OrigOrdModTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigOrdModTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigOrdModTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrigOrdModTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrigOrdModTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OrigOrdModTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigOrdModTime *)new FIX::OrigOrdModTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigOrdModTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigOrdModTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrigOrdModTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrigOrdModTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrigOrdModTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrigOrdModTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigOrdModTime *)new FIX::OrigOrdModTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigOrdModTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigOrdModTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::OrigOrdModTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_OrigOrdModTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrigOrdModTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrigOrdModTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OrigOrdModTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigOrdModTime *)new FIX::OrigOrdModTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigOrdModTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigOrdModTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrigOrdModTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigOrdModTime__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_OrigOrdModTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_OrigOrdModTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrigOrdModTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrigOrdModTime::OrigOrdModTime()\n"
    "    FIX::OrigOrdModTime::OrigOrdModTime(bool)\n"
    "    FIX::OrigOrdModTime::OrigOrdModTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::OrigOrdModTime::OrigOrdModTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrigOrdModTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigOrdModTime *arg1 = (FIX::OrigOrdModTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrigOrdModTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrigOrdModTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrigOrdModTime" "', argument " "1"" of type '" "FIX::OrigOrdModTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrigOrdModTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrigOrdModTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrigOrdModTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoTrdRepIndicators__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTrdRepIndicators *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoTrdRepIndicators")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTrdRepIndicators *)new FIX::NoTrdRepIndicators();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTrdRepIndicators, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTrdRepIndicators__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoTrdRepIndicators *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoTrdRepIndicators",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoTrdRepIndicators" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoTrdRepIndicators" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTrdRepIndicators *)new FIX::NoTrdRepIndicators((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTrdRepIndicators, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTrdRepIndicators(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoTrdRepIndicators__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTrdRepIndicators__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoTrdRepIndicators'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoTrdRepIndicators::NoTrdRepIndicators()\n"
    "    FIX::NoTrdRepIndicators::NoTrdRepIndicators(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoTrdRepIndicators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTrdRepIndicators *arg1 = (FIX::NoTrdRepIndicators *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoTrdRepIndicators",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoTrdRepIndicators, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoTrdRepIndicators" "', argument " "1"" of type '" "FIX::NoTrdRepIndicators *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoTrdRepIndicators * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoTrdRepIndicators_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoTrdRepIndicators, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeMaturityDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeMaturityDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeMaturityDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeMaturityDate *)new FIX::DerivativeMaturityDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeMaturityDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMaturityDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeMaturityDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeMaturityDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeMaturityDate *)new FIX::DerivativeMaturityDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeMaturityDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeMaturityDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeMaturityDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeMaturityDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeMaturityDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeMaturityDate::DerivativeMaturityDate()\n"
    "    FIX::DerivativeMaturityDate::DerivativeMaturityDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeMaturityDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeMaturityDate *arg1 = (FIX::DerivativeMaturityDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeMaturityDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeMaturityDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeMaturityDate" "', argument " "1"" of type '" "FIX::DerivativeMaturityDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeMaturityDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeMaturityDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeMaturityDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeCFICode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeCFICode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeCFICode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeCFICode *)new FIX::DerivativeCFICode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeCFICode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeCFICode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeCFICode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeCFICode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeCFICode *)new FIX::DerivativeCFICode((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeCFICode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeCFICode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeCFICode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeCFICode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeCFICode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeCFICode::DerivativeCFICode()\n"
    "    FIX::DerivativeCFICode::DerivativeCFICode(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeCFICode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeCFICode *arg1 = (FIX::DerivativeCFICode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeCFICode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeCFICode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeCFICode" "', argument " "1"" of type '" "FIX::DerivativeCFICode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeCFICode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeCFICode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeCFICode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Nested2PartySubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested2PartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested2PartySubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested2PartySubIDType *)new FIX::Nested2PartySubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested2PartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested2PartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested2PartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested2PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested2PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested2PartySubIDType *)new FIX::Nested2PartySubIDType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested2PartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested2PartySubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested2PartySubIDType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested2PartySubIDType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested2PartySubIDType::Nested2PartySubIDType()\n"
    "    FIX::Nested2PartySubIDType::Nested2PartySubIDType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested2PartySubIDType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested2PartySubIDType *arg1 = (FIX::Nested2PartySubIDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested2PartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested2PartySubIDType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested2PartySubIDType" "', argument " "1"" of type '" "FIX::Nested2PartySubIDType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested2PartySubIDType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Nested2PartySubIDType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Nested2PartySubIDType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegIOIQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegIOIQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegIOIQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegIOIQty *)new FIX::LegIOIQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegIOIQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIOIQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegIOIQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegIOIQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegIOIQty" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegIOIQty" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegIOIQty *)new FIX::LegIOIQty((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegIOIQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIOIQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegIOIQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegIOIQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegIOIQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegIOIQty::LegIOIQty()\n"
    "    FIX::LegIOIQty::LegIOIQty(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegIOIQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegIOIQty *arg1 = (FIX::LegIOIQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegIOIQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegIOIQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegIOIQty" "', argument " "1"" of type '" "FIX::LegIOIQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegIOIQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegIOIQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegIOIQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExpireDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExpireDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExpireDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExpireDate *)new FIX::ExpireDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExpireDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpireDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExpireDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExpireDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExpireDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExpireDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExpireDate *)new FIX::ExpireDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExpireDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpireDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExpireDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExpireDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExpireDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExpireDate::ExpireDate()\n"
    "    FIX::ExpireDate::ExpireDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExpireDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExpireDate *arg1 = (FIX::ExpireDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExpireDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExpireDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExpireDate" "', argument " "1"" of type '" "FIX::ExpireDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExpireDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExpireDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ExpireDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoMatchRules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMatchRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoMatchRules")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMatchRules *)new FIX::NoMatchRules();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMatchRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMatchRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoMatchRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoMatchRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoMatchRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoMatchRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoMatchRules *)new FIX::NoMatchRules((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoMatchRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoMatchRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoMatchRules__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoMatchRules__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoMatchRules'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoMatchRules::NoMatchRules()\n"
    "    FIX::NoMatchRules::NoMatchRules(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoMatchRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoMatchRules *arg1 = (FIX::NoMatchRules *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoMatchRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoMatchRules, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoMatchRules" "', argument " "1"" of type '" "FIX::NoMatchRules *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoMatchRules * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoMatchRules_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoMatchRules, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ApplEndSeqNum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplEndSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplEndSeqNum")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplEndSeqNum *)new FIX::ApplEndSeqNum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplEndSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplEndSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplEndSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplEndSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SEQNUM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplEndSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplEndSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplEndSeqNum *)new FIX::ApplEndSeqNum((FIX::SEQNUM const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplEndSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplEndSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplEndSeqNum__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplEndSeqNum__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplEndSeqNum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplEndSeqNum::ApplEndSeqNum()\n"
    "    FIX::ApplEndSeqNum::ApplEndSeqNum(FIX::SEQNUM const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplEndSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplEndSeqNum *arg1 = (FIX::ApplEndSeqNum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplEndSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplEndSeqNum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplEndSeqNum" "', argument " "1"" of type '" "FIX::ApplEndSeqNum *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplEndSeqNum * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ApplEndSeqNum_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ApplEndSeqNum, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EventPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EventPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EventPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EventPx *)new FIX::EventPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EventPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EventPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EventPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EventPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EventPx *)new FIX::EventPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EventPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EventPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EventPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EventPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EventPx::EventPx()\n"
    "    FIX::EventPx::EventPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EventPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EventPx *arg1 = (FIX::EventPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EventPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EventPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventPx" "', argument " "1"" of type '" "FIX::EventPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EventPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EventPx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EventPx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AsgnRptID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AsgnRptID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AsgnRptID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AsgnRptID *)new FIX::AsgnRptID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AsgnRptID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AsgnRptID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AsgnRptID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AsgnRptID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AsgnRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AsgnRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AsgnRptID *)new FIX::AsgnRptID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AsgnRptID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AsgnRptID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AsgnRptID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AsgnRptID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AsgnRptID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AsgnRptID::AsgnRptID()\n"
    "    FIX::AsgnRptID::AsgnRptID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AsgnRptID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AsgnRptID *arg1 = (FIX::AsgnRptID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AsgnRptID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AsgnRptID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AsgnRptID" "', argument " "1"" of type '" "FIX::AsgnRptID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AsgnRptID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AsgnRptID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AsgnRptID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TimeInForce__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TimeInForce *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TimeInForce")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TimeInForce *)new FIX::TimeInForce();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TimeInForce, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeInForce__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TimeInForce *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TimeInForce",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimeInForce" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimeInForce" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TimeInForce *)new FIX::TimeInForce((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TimeInForce, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeInForce(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TimeInForce__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TimeInForce__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TimeInForce'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TimeInForce::TimeInForce()\n"
    "    FIX::TimeInForce::TimeInForce(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TimeInForce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TimeInForce *arg1 = (FIX::TimeInForce *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TimeInForce",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TimeInForce, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeInForce" "', argument " "1"" of type '" "FIX::TimeInForce *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TimeInForce * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TimeInForce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TimeInForce, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LowPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LowPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LowPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LowPx *)new FIX::LowPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LowPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LowPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LowPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LowPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LowPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LowPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LowPx *)new FIX::LowPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LowPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LowPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LowPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LowPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LowPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LowPx::LowPx()\n"
    "    FIX::LowPx::LowPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LowPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LowPx *arg1 = (FIX::LowPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LowPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LowPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LowPx" "', argument " "1"" of type '" "FIX::LowPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LowPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LowPx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LowPx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_IOIQualifier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIQualifier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IOIQualifier")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIQualifier *)new FIX::IOIQualifier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIQualifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIQualifier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IOIQualifier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IOIQualifier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOIQualifier" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IOIQualifier" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIQualifier *)new FIX::IOIQualifier((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIQualifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIQualifier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IOIQualifier__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIQualifier__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IOIQualifier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IOIQualifier::IOIQualifier()\n"
    "    FIX::IOIQualifier::IOIQualifier(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IOIQualifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIQualifier *arg1 = (FIX::IOIQualifier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IOIQualifier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IOIQualifier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOIQualifier" "', argument " "1"" of type '" "FIX::IOIQualifier *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IOIQualifier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IOIQualifier_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__IOIQualifier, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_WaveNo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::WaveNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_WaveNo")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::WaveNo *)new FIX::WaveNo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__WaveNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WaveNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::WaveNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_WaveNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WaveNo" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_WaveNo" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::WaveNo *)new FIX::WaveNo((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__WaveNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WaveNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_WaveNo__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_WaveNo__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_WaveNo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::WaveNo::WaveNo()\n"
    "    FIX::WaveNo::WaveNo(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_WaveNo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::WaveNo *arg1 = (FIX::WaveNo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_WaveNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__WaveNo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WaveNo" "', argument " "1"" of type '" "FIX::WaveNo *""'"); 
  }
  arg1 = reinterpret_cast< FIX::WaveNo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *WaveNo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__WaveNo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StrikePriceBoundaryMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikePriceBoundaryMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StrikePriceBoundaryMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikePriceBoundaryMethod *)new FIX::StrikePriceBoundaryMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikePriceBoundaryMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePriceBoundaryMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrikePriceBoundaryMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrikePriceBoundaryMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrikePriceBoundaryMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrikePriceBoundaryMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikePriceBoundaryMethod *)new FIX::StrikePriceBoundaryMethod((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikePriceBoundaryMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePriceBoundaryMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StrikePriceBoundaryMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikePriceBoundaryMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StrikePriceBoundaryMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StrikePriceBoundaryMethod::StrikePriceBoundaryMethod()\n"
    "    FIX::StrikePriceBoundaryMethod::StrikePriceBoundaryMethod(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StrikePriceBoundaryMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikePriceBoundaryMethod *arg1 = (FIX::StrikePriceBoundaryMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrikePriceBoundaryMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StrikePriceBoundaryMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrikePriceBoundaryMethod" "', argument " "1"" of type '" "FIX::StrikePriceBoundaryMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StrikePriceBoundaryMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StrikePriceBoundaryMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__StrikePriceBoundaryMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeIssueDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeIssueDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeIssueDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeIssueDate *)new FIX::DerivativeIssueDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeIssueDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeIssueDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeIssueDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeIssueDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeIssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeIssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeIssueDate *)new FIX::DerivativeIssueDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeIssueDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeIssueDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeIssueDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeIssueDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeIssueDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeIssueDate::DerivativeIssueDate()\n"
    "    FIX::DerivativeIssueDate::DerivativeIssueDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeIssueDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeIssueDate *arg1 = (FIX::DerivativeIssueDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeIssueDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeIssueDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeIssueDate" "', argument " "1"" of type '" "FIX::DerivativeIssueDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeIssueDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeIssueDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeIssueDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MiscFeeType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MiscFeeType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MiscFeeType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MiscFeeType *)new FIX::MiscFeeType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MiscFeeType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MiscFeeType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MiscFeeType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MiscFeeType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MiscFeeType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MiscFeeType *)new FIX::MiscFeeType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MiscFeeType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MiscFeeType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MiscFeeType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MiscFeeType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MiscFeeType::MiscFeeType()\n"
    "    FIX::MiscFeeType::MiscFeeType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MiscFeeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MiscFeeType *arg1 = (FIX::MiscFeeType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MiscFeeType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MiscFeeType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MiscFeeType" "', argument " "1"" of type '" "FIX::MiscFeeType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MiscFeeType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MiscFeeType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MiscFeeType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_QuoteID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteID *)new FIX::QuoteID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteID *)new FIX::QuoteID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteID::QuoteID()\n"
    "    FIX::QuoteID::QuoteID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteID *arg1 = (FIX::QuoteID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteID" "', argument " "1"" of type '" "FIX::QuoteID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__QuoteID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrumentPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeInstrumentPartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrumentPartyIDSource *)new FIX::DerivativeInstrumentPartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrumentPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeInstrumentPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeInstrumentPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrumentPartyIDSource *)new FIX::DerivativeInstrumentPartyIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrumentPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeInstrumentPartyIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrumentPartyIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeInstrumentPartyIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeInstrumentPartyIDSource::DerivativeInstrumentPartyIDSource()\n"
    "    FIX::DerivativeInstrumentPartyIDSource::DerivativeInstrumentPartyIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeInstrumentPartyIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrumentPartyIDSource *arg1 = (FIX::DerivativeInstrumentPartyIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeInstrumentPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeInstrumentPartyIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeInstrumentPartyIDSource" "', argument " "1"" of type '" "FIX::DerivativeInstrumentPartyIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeInstrumentPartyIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeInstrumentPartyIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeInstrumentPartyIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlObligID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlObligID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlObligID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlObligID *)new FIX::SettlObligID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlObligID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlObligID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlObligID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlObligID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlObligID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlObligID *)new FIX::SettlObligID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlObligID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlObligID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlObligID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlObligID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlObligID::SettlObligID()\n"
    "    FIX::SettlObligID::SettlObligID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlObligID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlObligID *arg1 = (FIX::SettlObligID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlObligID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlObligID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlObligID" "', argument " "1"" of type '" "FIX::SettlObligID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlObligID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlObligID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlObligID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_InstrAttribValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrAttribValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InstrAttribValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrAttribValue *)new FIX::InstrAttribValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrAttribValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrAttribValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InstrAttribValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InstrAttribValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstrAttribValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InstrAttribValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrAttribValue *)new FIX::InstrAttribValue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrAttribValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrAttribValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InstrAttribValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrAttribValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InstrAttribValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InstrAttribValue::InstrAttribValue()\n"
    "    FIX::InstrAttribValue::InstrAttribValue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InstrAttribValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrAttribValue *arg1 = (FIX::InstrAttribValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InstrAttribValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InstrAttribValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InstrAttribValue" "', argument " "1"" of type '" "FIX::InstrAttribValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InstrAttribValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InstrAttribValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__InstrAttribValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LiquidityValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LiquidityValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LiquidityValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LiquidityValue *)new FIX::LiquidityValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LiquidityValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LiquidityValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LiquidityValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LiquidityValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LiquidityValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LiquidityValue *)new FIX::LiquidityValue((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LiquidityValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LiquidityValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LiquidityValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LiquidityValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LiquidityValue::LiquidityValue()\n"
    "    FIX::LiquidityValue::LiquidityValue(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LiquidityValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LiquidityValue *arg1 = (FIX::LiquidityValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LiquidityValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LiquidityValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LiquidityValue" "', argument " "1"" of type '" "FIX::LiquidityValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LiquidityValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LiquidityValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LiquidityValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityIDSource *)new FIX::SecurityIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityIDSource *)new FIX::SecurityIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityIDSource::SecurityIDSource()\n"
    "    FIX::SecurityIDSource::SecurityIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityIDSource *arg1 = (FIX::SecurityIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityIDSource" "', argument " "1"" of type '" "FIX::SecurityIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NewsRefType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NewsRefType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NewsRefType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NewsRefType *)new FIX::NewsRefType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NewsRefType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsRefType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NewsRefType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NewsRefType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewsRefType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NewsRefType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NewsRefType *)new FIX::NewsRefType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NewsRefType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewsRefType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NewsRefType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NewsRefType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NewsRefType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NewsRefType::NewsRefType()\n"
    "    FIX::NewsRefType::NewsRefType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NewsRefType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NewsRefType *arg1 = (FIX::NewsRefType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NewsRefType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NewsRefType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewsRefType" "', argument " "1"" of type '" "FIX::NewsRefType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NewsRefType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NewsRefType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NewsRefType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoOfLegUnderlyings__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoOfLegUnderlyings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoOfLegUnderlyings")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoOfLegUnderlyings *)new FIX::NoOfLegUnderlyings();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoOfLegUnderlyings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOfLegUnderlyings__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoOfLegUnderlyings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoOfLegUnderlyings",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoOfLegUnderlyings" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoOfLegUnderlyings" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoOfLegUnderlyings *)new FIX::NoOfLegUnderlyings((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoOfLegUnderlyings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOfLegUnderlyings(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoOfLegUnderlyings__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoOfLegUnderlyings__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoOfLegUnderlyings'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoOfLegUnderlyings::NoOfLegUnderlyings()\n"
    "    FIX::NoOfLegUnderlyings::NoOfLegUnderlyings(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoOfLegUnderlyings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoOfLegUnderlyings *arg1 = (FIX::NoOfLegUnderlyings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoOfLegUnderlyings",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoOfLegUnderlyings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoOfLegUnderlyings" "', argument " "1"" of type '" "FIX::NoOfLegUnderlyings *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoOfLegUnderlyings * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoOfLegUnderlyings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoOfLegUnderlyings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeEncodedSecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEncodedSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeEncodedSecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEncodedSecurityDesc *)new FIX::DerivativeEncodedSecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEncodedSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeEncodedSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeEncodedSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeEncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeEncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeEncodedSecurityDesc *)new FIX::DerivativeEncodedSecurityDesc((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeEncodedSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeEncodedSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeEncodedSecurityDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeEncodedSecurityDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeEncodedSecurityDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeEncodedSecurityDesc::DerivativeEncodedSecurityDesc()\n"
    "    FIX::DerivativeEncodedSecurityDesc::DerivativeEncodedSecurityDesc(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeEncodedSecurityDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeEncodedSecurityDesc *arg1 = (FIX::DerivativeEncodedSecurityDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeEncodedSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeEncodedSecurityDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeEncodedSecurityDesc" "', argument " "1"" of type '" "FIX::DerivativeEncodedSecurityDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeEncodedSecurityDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeEncodedSecurityDesc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeEncodedSecurityDesc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TriggerOrderType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerOrderType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerOrderType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerOrderType *)new FIX::TriggerOrderType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerOrderType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerOrderType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerOrderType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerOrderType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerOrderType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerOrderType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerOrderType *)new FIX::TriggerOrderType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerOrderType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerOrderType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerOrderType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerOrderType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerOrderType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerOrderType::TriggerOrderType()\n"
    "    FIX::TriggerOrderType::TriggerOrderType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerOrderType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerOrderType *arg1 = (FIX::TriggerOrderType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerOrderType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerOrderType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerOrderType" "', argument " "1"" of type '" "FIX::TriggerOrderType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerOrderType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TriggerOrderType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TriggerOrderType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingDirtyPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingDirtyPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingDirtyPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingDirtyPrice *)new FIX::UnderlyingDirtyPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingDirtyPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingDirtyPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingDirtyPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingDirtyPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingDirtyPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingDirtyPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingDirtyPrice *)new FIX::UnderlyingDirtyPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingDirtyPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingDirtyPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingDirtyPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingDirtyPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingDirtyPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingDirtyPrice::UnderlyingDirtyPrice()\n"
    "    FIX::UnderlyingDirtyPrice::UnderlyingDirtyPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingDirtyPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingDirtyPrice *arg1 = (FIX::UnderlyingDirtyPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingDirtyPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingDirtyPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingDirtyPrice" "', argument " "1"" of type '" "FIX::UnderlyingDirtyPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingDirtyPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingDirtyPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingDirtyPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CrossType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CrossType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CrossType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CrossType *)new FIX::CrossType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CrossType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CrossType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CrossType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CrossType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CrossType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CrossType *)new FIX::CrossType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CrossType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CrossType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CrossType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CrossType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CrossType::CrossType()\n"
    "    FIX::CrossType::CrossType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CrossType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CrossType *arg1 = (FIX::CrossType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CrossType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CrossType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CrossType" "', argument " "1"" of type '" "FIX::CrossType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CrossType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CrossType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CrossType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RepoCollateralSecurityType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepoCollateralSecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RepoCollateralSecurityType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RepoCollateralSecurityType *)new FIX::RepoCollateralSecurityType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepoCollateralSecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepoCollateralSecurityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RepoCollateralSecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RepoCollateralSecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RepoCollateralSecurityType *)new FIX::RepoCollateralSecurityType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RepoCollateralSecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RepoCollateralSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RepoCollateralSecurityType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RepoCollateralSecurityType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RepoCollateralSecurityType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RepoCollateralSecurityType::RepoCollateralSecurityType()\n"
    "    FIX::RepoCollateralSecurityType::RepoCollateralSecurityType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RepoCollateralSecurityType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RepoCollateralSecurityType *arg1 = (FIX::RepoCollateralSecurityType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RepoCollateralSecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RepoCollateralSecurityType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RepoCollateralSecurityType" "', argument " "1"" of type '" "FIX::RepoCollateralSecurityType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RepoCollateralSecurityType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RepoCollateralSecurityType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RepoCollateralSecurityType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Password__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Password *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Password")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Password *)new FIX::Password();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Password, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Password__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Password *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Password",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Password" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Password" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Password *)new FIX::Password((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Password, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Password(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Password__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Password__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Password'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Password::Password()\n"
    "    FIX::Password::Password(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Password(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Password *arg1 = (FIX::Password *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Password",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Password, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Password" "', argument " "1"" of type '" "FIX::Password *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Password * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Password_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Password, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OpenCloseSettleFlag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OpenCloseSettleFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OpenCloseSettleFlag")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OpenCloseSettleFlag *)new FIX::OpenCloseSettleFlag();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OpenCloseSettleFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenCloseSettleFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLEVALUESTRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OpenCloseSettleFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OpenCloseSettleFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MULTIPLEVALUESTRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OpenCloseSettleFlag" "', argument " "1"" of type '" "FIX::MULTIPLEVALUESTRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OpenCloseSettleFlag" "', argument " "1"" of type '" "FIX::MULTIPLEVALUESTRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLEVALUESTRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OpenCloseSettleFlag *)new FIX::OpenCloseSettleFlag((FIX::MULTIPLEVALUESTRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OpenCloseSettleFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenCloseSettleFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OpenCloseSettleFlag__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MULTIPLEVALUESTRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OpenCloseSettleFlag__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OpenCloseSettleFlag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OpenCloseSettleFlag::OpenCloseSettleFlag()\n"
    "    FIX::OpenCloseSettleFlag::OpenCloseSettleFlag(FIX::MULTIPLEVALUESTRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OpenCloseSettleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OpenCloseSettleFlag *arg1 = (FIX::OpenCloseSettleFlag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OpenCloseSettleFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OpenCloseSettleFlag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OpenCloseSettleFlag" "', argument " "1"" of type '" "FIX::OpenCloseSettleFlag *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OpenCloseSettleFlag * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OpenCloseSettleFlag_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OpenCloseSettleFlag, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Subject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Subject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Subject")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Subject *)new FIX::Subject();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Subject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Subject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Subject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Subject",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Subject" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Subject" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Subject *)new FIX::Subject((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Subject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Subject(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Subject__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Subject__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Subject'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Subject::Subject()\n"
    "    FIX::Subject::Subject(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Subject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Subject *arg1 = (FIX::Subject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Subject",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Subject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Subject" "', argument " "1"" of type '" "FIX::Subject *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Subject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Subject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Subject, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RefApplReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefApplReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefApplReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefApplReqID *)new FIX::RefApplReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefApplReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefApplReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefApplReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefApplReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefApplReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefApplReqID *)new FIX::RefApplReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefApplReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefApplReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefApplReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefApplReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefApplReqID::RefApplReqID()\n"
    "    FIX::RefApplReqID::RefApplReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefApplReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefApplReqID *arg1 = (FIX::RefApplReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefApplReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefApplReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefApplReqID" "', argument " "1"" of type '" "FIX::RefApplReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefApplReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RefApplReqID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RefApplReqID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingEndValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingEndValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingEndValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingEndValue *)new FIX::UnderlyingEndValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingEndValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingEndValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingEndValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingEndValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingEndValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingEndValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingEndValue *)new FIX::UnderlyingEndValue((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingEndValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingEndValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingEndValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingEndValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingEndValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingEndValue::UnderlyingEndValue()\n"
    "    FIX::UnderlyingEndValue::UnderlyingEndValue(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingEndValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingEndValue *arg1 = (FIX::UnderlyingEndValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingEndValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingEndValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingEndValue" "', argument " "1"" of type '" "FIX::UnderlyingEndValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingEndValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingEndValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingEndValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NewSeqNo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NewSeqNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NewSeqNo")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NewSeqNo *)new FIX::NewSeqNo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NewSeqNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewSeqNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NewSeqNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NewSeqNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SEQNUM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewSeqNo" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NewSeqNo" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NewSeqNo *)new FIX::NewSeqNo((FIX::SEQNUM const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NewSeqNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NewSeqNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NewSeqNo__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NewSeqNo__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NewSeqNo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NewSeqNo::NewSeqNo()\n"
    "    FIX::NewSeqNo::NewSeqNo(FIX::SEQNUM const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NewSeqNo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NewSeqNo *arg1 = (FIX::NewSeqNo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NewSeqNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NewSeqNo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewSeqNo" "', argument " "1"" of type '" "FIX::NewSeqNo *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NewSeqNo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NewSeqNo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NewSeqNo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OrigTradeHandlingInstr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigTradeHandlingInstr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrigTradeHandlingInstr")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigTradeHandlingInstr *)new FIX::OrigTradeHandlingInstr();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigTradeHandlingInstr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTradeHandlingInstr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrigTradeHandlingInstr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrigTradeHandlingInstr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrigTradeHandlingInstr" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrigTradeHandlingInstr" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigTradeHandlingInstr *)new FIX::OrigTradeHandlingInstr((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigTradeHandlingInstr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTradeHandlingInstr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrigTradeHandlingInstr__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigTradeHandlingInstr__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrigTradeHandlingInstr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrigTradeHandlingInstr::OrigTradeHandlingInstr()\n"
    "    FIX::OrigTradeHandlingInstr::OrigTradeHandlingInstr(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrigTradeHandlingInstr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigTradeHandlingInstr *arg1 = (FIX::OrigTradeHandlingInstr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrigTradeHandlingInstr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrigTradeHandlingInstr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrigTradeHandlingInstr" "', argument " "1"" of type '" "FIX::OrigTradeHandlingInstr *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrigTradeHandlingInstr * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrigTradeHandlingInstr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrigTradeHandlingInstr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DisplayHighQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DisplayHighQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DisplayHighQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DisplayHighQty *)new FIX::DisplayHighQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DisplayHighQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayHighQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DisplayHighQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DisplayHighQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DisplayHighQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DisplayHighQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DisplayHighQty *)new FIX::DisplayHighQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DisplayHighQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayHighQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DisplayHighQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DisplayHighQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DisplayHighQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DisplayHighQty::DisplayHighQty()\n"
    "    FIX::DisplayHighQty::DisplayHighQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DisplayHighQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DisplayHighQty *arg1 = (FIX::DisplayHighQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DisplayHighQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DisplayHighQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DisplayHighQty" "', argument " "1"" of type '" "FIX::DisplayHighQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DisplayHighQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DisplayHighQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DisplayHighQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MDBookType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDBookType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDBookType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDBookType *)new FIX::MDBookType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDBookType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDBookType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDBookType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDBookType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDBookType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDBookType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDBookType *)new FIX::MDBookType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDBookType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDBookType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDBookType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDBookType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDBookType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDBookType::MDBookType()\n"
    "    FIX::MDBookType::MDBookType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDBookType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDBookType *arg1 = (FIX::MDBookType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDBookType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDBookType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDBookType" "', argument " "1"" of type '" "FIX::MDBookType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDBookType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MDBookType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MDBookType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MarginExcess__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarginExcess *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MarginExcess")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarginExcess *)new FIX::MarginExcess();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarginExcess, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarginExcess__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MarginExcess *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MarginExcess",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarginExcess" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarginExcess" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarginExcess *)new FIX::MarginExcess((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarginExcess, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarginExcess(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MarginExcess__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarginExcess__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarginExcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MarginExcess::MarginExcess()\n"
    "    FIX::MarginExcess::MarginExcess(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MarginExcess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarginExcess *arg1 = (FIX::MarginExcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MarginExcess",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MarginExcess, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarginExcess" "', argument " "1"" of type '" "FIX::MarginExcess *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MarginExcess * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MarginExcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MarginExcess, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BasisPxType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BasisPxType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BasisPxType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BasisPxType *)new FIX::BasisPxType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BasisPxType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BasisPxType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BasisPxType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BasisPxType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BasisPxType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BasisPxType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BasisPxType *)new FIX::BasisPxType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BasisPxType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BasisPxType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BasisPxType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BasisPxType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BasisPxType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BasisPxType::BasisPxType()\n"
    "    FIX::BasisPxType::BasisPxType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BasisPxType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BasisPxType *arg1 = (FIX::BasisPxType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BasisPxType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BasisPxType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BasisPxType" "', argument " "1"" of type '" "FIX::BasisPxType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BasisPxType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BasisPxType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BasisPxType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DlvyInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DlvyInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DlvyInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DlvyInst *)new FIX::DlvyInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DlvyInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DlvyInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DlvyInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DlvyInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DlvyInst" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DlvyInst" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DlvyInst *)new FIX::DlvyInst((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DlvyInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DlvyInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DlvyInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DlvyInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DlvyInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DlvyInst::DlvyInst()\n"
    "    FIX::DlvyInst::DlvyInst(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DlvyInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DlvyInst *arg1 = (FIX::DlvyInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DlvyInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DlvyInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DlvyInst" "', argument " "1"" of type '" "FIX::DlvyInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DlvyInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DlvyInst_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DlvyInst, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ComplianceID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplianceID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ComplianceID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplianceID *)new FIX::ComplianceID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplianceID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplianceID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ComplianceID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ComplianceID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplianceID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplianceID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplianceID *)new FIX::ComplianceID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplianceID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplianceID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ComplianceID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplianceID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ComplianceID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ComplianceID::ComplianceID()\n"
    "    FIX::ComplianceID::ComplianceID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ComplianceID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplianceID *arg1 = (FIX::ComplianceID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ComplianceID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ComplianceID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComplianceID" "', argument " "1"" of type '" "FIX::ComplianceID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ComplianceID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ComplianceID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ComplianceID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EmailThreadID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EmailThreadID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EmailThreadID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EmailThreadID *)new FIX::EmailThreadID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EmailThreadID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EmailThreadID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EmailThreadID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EmailThreadID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EmailThreadID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EmailThreadID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EmailThreadID *)new FIX::EmailThreadID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EmailThreadID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EmailThreadID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EmailThreadID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EmailThreadID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EmailThreadID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EmailThreadID::EmailThreadID()\n"
    "    FIX::EmailThreadID::EmailThreadID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EmailThreadID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EmailThreadID *arg1 = (FIX::EmailThreadID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EmailThreadID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EmailThreadID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EmailThreadID" "', argument " "1"" of type '" "FIX::EmailThreadID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EmailThreadID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EmailThreadID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EmailThreadID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ContAmtCurr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContAmtCurr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ContAmtCurr")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContAmtCurr *)new FIX::ContAmtCurr();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContAmtCurr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContAmtCurr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContAmtCurr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContAmtCurr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContAmtCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContAmtCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContAmtCurr *)new FIX::ContAmtCurr((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContAmtCurr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContAmtCurr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ContAmtCurr__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContAmtCurr__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContAmtCurr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ContAmtCurr::ContAmtCurr()\n"
    "    FIX::ContAmtCurr::ContAmtCurr(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ContAmtCurr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContAmtCurr *arg1 = (FIX::ContAmtCurr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContAmtCurr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ContAmtCurr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContAmtCurr" "', argument " "1"" of type '" "FIX::ContAmtCurr *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ContAmtCurr * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ContAmtCurr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ContAmtCurr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ComplexEventType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ComplexEventType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventType *)new FIX::ComplexEventType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ComplexEventType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ComplexEventType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexEventType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplexEventType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventType *)new FIX::ComplexEventType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ComplexEventType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ComplexEventType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ComplexEventType::ComplexEventType()\n"
    "    FIX::ComplexEventType::ComplexEventType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ComplexEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventType *arg1 = (FIX::ComplexEventType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ComplexEventType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ComplexEventType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComplexEventType" "', argument " "1"" of type '" "FIX::ComplexEventType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ComplexEventType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ComplexEventType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ComplexEventType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MassActionResponse__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassActionResponse *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MassActionResponse")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassActionResponse *)new FIX::MassActionResponse();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassActionResponse, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionResponse__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MassActionResponse *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MassActionResponse",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassActionResponse" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassActionResponse" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassActionResponse *)new FIX::MassActionResponse((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassActionResponse, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassActionResponse(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MassActionResponse__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassActionResponse__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MassActionResponse'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MassActionResponse::MassActionResponse()\n"
    "    FIX::MassActionResponse::MassActionResponse(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MassActionResponse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassActionResponse *arg1 = (FIX::MassActionResponse *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MassActionResponse",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MassActionResponse, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MassActionResponse" "', argument " "1"" of type '" "FIX::MassActionResponse *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MassActionResponse * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MassActionResponse_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MassActionResponse, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingIssueDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingIssueDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingIssueDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingIssueDate *)new FIX::UnderlyingIssueDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingIssueDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingIssueDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingIssueDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingIssueDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingIssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingIssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingIssueDate *)new FIX::UnderlyingIssueDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingIssueDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingIssueDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingIssueDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingIssueDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingIssueDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingIssueDate::UnderlyingIssueDate()\n"
    "    FIX::UnderlyingIssueDate::UnderlyingIssueDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingIssueDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingIssueDate *arg1 = (FIX::UnderlyingIssueDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingIssueDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingIssueDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingIssueDate" "', argument " "1"" of type '" "FIX::UnderlyingIssueDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingIssueDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingIssueDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingIssueDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityRequestType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityRequestType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityRequestType *)new FIX::SecurityRequestType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityRequestType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityRequestType *)new FIX::SecurityRequestType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityRequestType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityRequestType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityRequestType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityRequestType::SecurityRequestType()\n"
    "    FIX::SecurityRequestType::SecurityRequestType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityRequestType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityRequestType *arg1 = (FIX::SecurityRequestType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityRequestType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityRequestType" "', argument " "1"" of type '" "FIX::SecurityRequestType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityRequestType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityRequestType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityRequestType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocInterestAtMaturity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocInterestAtMaturity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocInterestAtMaturity")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocInterestAtMaturity *)new FIX::AllocInterestAtMaturity();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocInterestAtMaturity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocInterestAtMaturity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocInterestAtMaturity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocInterestAtMaturity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocInterestAtMaturity" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocInterestAtMaturity" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocInterestAtMaturity *)new FIX::AllocInterestAtMaturity((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocInterestAtMaturity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocInterestAtMaturity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocInterestAtMaturity__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocInterestAtMaturity__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocInterestAtMaturity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocInterestAtMaturity::AllocInterestAtMaturity()\n"
    "    FIX::AllocInterestAtMaturity::AllocInterestAtMaturity(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocInterestAtMaturity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocInterestAtMaturity *arg1 = (FIX::AllocInterestAtMaturity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocInterestAtMaturity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocInterestAtMaturity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocInterestAtMaturity" "', argument " "1"" of type '" "FIX::AllocInterestAtMaturity *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocInterestAtMaturity * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocInterestAtMaturity_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocInterestAtMaturity, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ListRejectReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ListRejectReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListRejectReason *)new FIX::ListRejectReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ListRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ListRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListRejectReason *)new FIX::ListRejectReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ListRejectReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListRejectReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ListRejectReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ListRejectReason::ListRejectReason()\n"
    "    FIX::ListRejectReason::ListRejectReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListRejectReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListRejectReason *arg1 = (FIX::ListRejectReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ListRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ListRejectReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListRejectReason" "', argument " "1"" of type '" "FIX::ListRejectReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ListRejectReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListRejectReason_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ListRejectReason, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DeskType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeskType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DeskType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeskType *)new FIX::DeskType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeskType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DeskType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DeskType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeskType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeskType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeskType *)new FIX::DeskType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeskType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DeskType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeskType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DeskType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DeskType::DeskType()\n"
    "    FIX::DeskType::DeskType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DeskType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeskType *arg1 = (FIX::DeskType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DeskType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DeskType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeskType" "', argument " "1"" of type '" "FIX::DeskType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DeskType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DeskType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DeskType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecondaryTradeReportID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryTradeReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryTradeReportID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryTradeReportID *)new FIX::SecondaryTradeReportID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryTradeReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradeReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryTradeReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryTradeReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryTradeReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryTradeReportID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryTradeReportID *)new FIX::SecondaryTradeReportID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryTradeReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradeReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryTradeReportID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryTradeReportID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryTradeReportID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryTradeReportID::SecondaryTradeReportID()\n"
    "    FIX::SecondaryTradeReportID::SecondaryTradeReportID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryTradeReportID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryTradeReportID *arg1 = (FIX::SecondaryTradeReportID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryTradeReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryTradeReportID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryTradeReportID" "', argument " "1"" of type '" "FIX::SecondaryTradeReportID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryTradeReportID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecondaryTradeReportID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecondaryTradeReportID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlType *)new FIX::SettlType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlType *)new FIX::SettlType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlType::SettlType()\n"
    "    FIX::SettlType::SettlType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlType *arg1 = (FIX::SettlType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlType" "', argument " "1"" of type '" "FIX::SettlType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OpenClose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OpenClose *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OpenClose")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OpenClose *)new FIX::OpenClose();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OpenClose, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenClose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OpenClose *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OpenClose",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OpenClose" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OpenClose" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OpenClose *)new FIX::OpenClose((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OpenClose, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OpenClose(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OpenClose__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OpenClose__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OpenClose'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OpenClose::OpenClose()\n"
    "    FIX::OpenClose::OpenClose(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OpenClose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OpenClose *arg1 = (FIX::OpenClose *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OpenClose",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OpenClose, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OpenClose" "', argument " "1"" of type '" "FIX::OpenClose *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OpenClose * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OpenClose_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OpenClose, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ContractMultiplierUnit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContractMultiplierUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ContractMultiplierUnit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContractMultiplierUnit *)new FIX::ContractMultiplierUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContractMultiplierUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContractMultiplierUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContractMultiplierUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContractMultiplierUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContractMultiplierUnit *)new FIX::ContractMultiplierUnit((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContractMultiplierUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContractMultiplierUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ContractMultiplierUnit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContractMultiplierUnit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContractMultiplierUnit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ContractMultiplierUnit::ContractMultiplierUnit()\n"
    "    FIX::ContractMultiplierUnit::ContractMultiplierUnit(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ContractMultiplierUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContractMultiplierUnit *arg1 = (FIX::ContractMultiplierUnit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContractMultiplierUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ContractMultiplierUnit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContractMultiplierUnit" "', argument " "1"" of type '" "FIX::ContractMultiplierUnit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ContractMultiplierUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ContractMultiplierUnit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ContractMultiplierUnit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecondaryLowLimitPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryLowLimitPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryLowLimitPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryLowLimitPrice *)new FIX::SecondaryLowLimitPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryLowLimitPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryLowLimitPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryLowLimitPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryLowLimitPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryLowLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryLowLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryLowLimitPrice *)new FIX::SecondaryLowLimitPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryLowLimitPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryLowLimitPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryLowLimitPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryLowLimitPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryLowLimitPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryLowLimitPrice::SecondaryLowLimitPrice()\n"
    "    FIX::SecondaryLowLimitPrice::SecondaryLowLimitPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryLowLimitPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryLowLimitPrice *arg1 = (FIX::SecondaryLowLimitPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryLowLimitPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryLowLimitPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryLowLimitPrice" "', argument " "1"" of type '" "FIX::SecondaryLowLimitPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryLowLimitPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecondaryLowLimitPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecondaryLowLimitPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExpQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExpQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExpQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExpQty *)new FIX::ExpQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExpQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExpQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExpQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExpQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExpQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExpQty *)new FIX::ExpQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExpQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExpQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExpQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExpQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExpQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExpQty::ExpQty()\n"
    "    FIX::ExpQty::ExpQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExpQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExpQty *arg1 = (FIX::ExpQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExpQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExpQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExpQty" "', argument " "1"" of type '" "FIX::ExpQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExpQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExpQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ExpQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NetworkRequestID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NetworkRequestID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NetworkRequestID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NetworkRequestID *)new FIX::NetworkRequestID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NetworkRequestID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkRequestID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NetworkRequestID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NetworkRequestID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NetworkRequestID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NetworkRequestID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NetworkRequestID *)new FIX::NetworkRequestID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NetworkRequestID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkRequestID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NetworkRequestID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NetworkRequestID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NetworkRequestID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NetworkRequestID::NetworkRequestID()\n"
    "    FIX::NetworkRequestID::NetworkRequestID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NetworkRequestID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NetworkRequestID *arg1 = (FIX::NetworkRequestID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NetworkRequestID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NetworkRequestID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NetworkRequestID" "', argument " "1"" of type '" "FIX::NetworkRequestID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NetworkRequestID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NetworkRequestID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NetworkRequestID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TrdType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TrdType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdType *)new FIX::TrdType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TrdType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TrdType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrdType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TrdType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdType *)new FIX::TrdType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TrdType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TrdType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TrdType::TrdType()\n"
    "    FIX::TrdType::TrdType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TrdType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdType *arg1 = (FIX::TrdType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TrdType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TrdType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrdType" "', argument " "1"" of type '" "FIX::TrdType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TrdType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TrdType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TrdType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoUnderlyings__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoUnderlyings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoUnderlyings")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoUnderlyings *)new FIX::NoUnderlyings();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoUnderlyings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyings__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoUnderlyings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoUnderlyings",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoUnderlyings" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoUnderlyings" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoUnderlyings *)new FIX::NoUnderlyings((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoUnderlyings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyings(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoUnderlyings__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoUnderlyings__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoUnderlyings'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoUnderlyings::NoUnderlyings()\n"
    "    FIX::NoUnderlyings::NoUnderlyings(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoUnderlyings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoUnderlyings *arg1 = (FIX::NoUnderlyings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoUnderlyings",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoUnderlyings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoUnderlyings" "', argument " "1"" of type '" "FIX::NoUnderlyings *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoUnderlyings * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoUnderlyings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoUnderlyings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MDMkt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDMkt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDMkt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDMkt *)new FIX::MDMkt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDMkt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDMkt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDMkt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDMkt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDMkt" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDMkt" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDMkt *)new FIX::MDMkt((FIX::EXCHANGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDMkt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDMkt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDMkt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDMkt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDMkt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDMkt::MDMkt()\n"
    "    FIX::MDMkt::MDMkt(FIX::EXCHANGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDMkt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDMkt *arg1 = (FIX::MDMkt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDMkt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDMkt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDMkt" "', argument " "1"" of type '" "FIX::MDMkt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDMkt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MDMkt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MDMkt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LastMkt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastMkt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastMkt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastMkt *)new FIX::LastMkt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastMkt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastMkt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastMkt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastMkt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastMkt" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastMkt" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastMkt *)new FIX::LastMkt((FIX::EXCHANGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastMkt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastMkt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastMkt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastMkt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastMkt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastMkt::LastMkt()\n"
    "    FIX::LastMkt::LastMkt(FIX::EXCHANGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastMkt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastMkt *arg1 = (FIX::LastMkt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastMkt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastMkt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastMkt" "', argument " "1"" of type '" "FIX::LastMkt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastMkt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LastMkt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LastMkt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RestructuringType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RestructuringType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RestructuringType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RestructuringType *)new FIX::RestructuringType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RestructuringType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RestructuringType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RestructuringType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RestructuringType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RestructuringType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RestructuringType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RestructuringType *)new FIX::RestructuringType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RestructuringType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RestructuringType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RestructuringType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RestructuringType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RestructuringType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RestructuringType::RestructuringType()\n"
    "    FIX::RestructuringType::RestructuringType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RestructuringType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RestructuringType *arg1 = (FIX::RestructuringType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RestructuringType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RestructuringType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RestructuringType" "', argument " "1"" of type '" "FIX::RestructuringType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RestructuringType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RestructuringType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RestructuringType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoStrikeRules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoStrikeRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoStrikeRules")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoStrikeRules *)new FIX::NoStrikeRules();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoStrikeRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStrikeRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoStrikeRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoStrikeRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoStrikeRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoStrikeRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoStrikeRules *)new FIX::NoStrikeRules((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoStrikeRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStrikeRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoStrikeRules__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoStrikeRules__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoStrikeRules'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoStrikeRules::NoStrikeRules()\n"
    "    FIX::NoStrikeRules::NoStrikeRules(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoStrikeRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoStrikeRules *arg1 = (FIX::NoStrikeRules *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoStrikeRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoStrikeRules, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoStrikeRules" "', argument " "1"" of type '" "FIX::NoStrikeRules *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoStrikeRules * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoStrikeRules_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoStrikeRules, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ListName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ListName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListName *)new FIX::ListName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ListName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ListName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListName *)new FIX::ListName((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ListName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListName__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ListName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ListName::ListName()\n"
    "    FIX::ListName::ListName(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListName *arg1 = (FIX::ListName *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ListName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ListName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListName" "', argument " "1"" of type '" "FIX::ListName *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ListName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListName_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ListName, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ProgRptReqs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ProgRptReqs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ProgRptReqs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ProgRptReqs *)new FIX::ProgRptReqs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ProgRptReqs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProgRptReqs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ProgRptReqs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ProgRptReqs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ProgRptReqs" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ProgRptReqs" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ProgRptReqs *)new FIX::ProgRptReqs((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ProgRptReqs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProgRptReqs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ProgRptReqs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ProgRptReqs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ProgRptReqs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ProgRptReqs::ProgRptReqs()\n"
    "    FIX::ProgRptReqs::ProgRptReqs(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ProgRptReqs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ProgRptReqs *arg1 = (FIX::ProgRptReqs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ProgRptReqs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ProgRptReqs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ProgRptReqs" "', argument " "1"" of type '" "FIX::ProgRptReqs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ProgRptReqs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ProgRptReqs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ProgRptReqs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradingSessionID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradingSessionID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradingSessionID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradingSessionID *)new FIX::TradingSessionID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradingSessionID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingSessionID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradingSessionID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradingSessionID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradingSessionID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradingSessionID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradingSessionID *)new FIX::TradingSessionID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradingSessionID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingSessionID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradingSessionID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradingSessionID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradingSessionID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradingSessionID::TradingSessionID()\n"
    "    FIX::TradingSessionID::TradingSessionID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradingSessionID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradingSessionID *arg1 = (FIX::TradingSessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradingSessionID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradingSessionID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradingSessionID" "', argument " "1"" of type '" "FIX::TradingSessionID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradingSessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradingSessionID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradingSessionID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ListOrderStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListOrderStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ListOrderStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListOrderStatus *)new FIX::ListOrderStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListOrderStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOrderStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ListOrderStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ListOrderStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListOrderStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListOrderStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListOrderStatus *)new FIX::ListOrderStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListOrderStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListOrderStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ListOrderStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListOrderStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ListOrderStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ListOrderStatus::ListOrderStatus()\n"
    "    FIX::ListOrderStatus::ListOrderStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListOrderStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListOrderStatus *arg1 = (FIX::ListOrderStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ListOrderStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ListOrderStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListOrderStatus" "', argument " "1"" of type '" "FIX::ListOrderStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ListOrderStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListOrderStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ListOrderStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RegistStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RegistStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistStatus *)new FIX::RegistStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RegistStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RegistStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegistStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegistStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistStatus *)new FIX::RegistStatus((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RegistStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RegistStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RegistStatus::RegistStatus()\n"
    "    FIX::RegistStatus::RegistStatus(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RegistStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistStatus *arg1 = (FIX::RegistStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RegistStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RegistStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegistStatus" "', argument " "1"" of type '" "FIX::RegistStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RegistStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RegistStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RegistStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PosAmt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PosAmt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosAmt *)new FIX::PosAmt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PosAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PosAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PosAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PosAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosAmt *)new FIX::PosAmt((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PosAmt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosAmt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PosAmt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PosAmt::PosAmt()\n"
    "    FIX::PosAmt::PosAmt(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PosAmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosAmt *arg1 = (FIX::PosAmt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PosAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PosAmt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PosAmt" "', argument " "1"" of type '" "FIX::PosAmt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PosAmt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PosAmt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PosAmt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingPriceDeterminationMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingPriceDeterminationMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingPriceDeterminationMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingPriceDeterminationMethod *)new FIX::UnderlyingPriceDeterminationMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingPriceDeterminationMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPriceDeterminationMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingPriceDeterminationMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingPriceDeterminationMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingPriceDeterminationMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingPriceDeterminationMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingPriceDeterminationMethod *)new FIX::UnderlyingPriceDeterminationMethod((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingPriceDeterminationMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPriceDeterminationMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingPriceDeterminationMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingPriceDeterminationMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingPriceDeterminationMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingPriceDeterminationMethod::UnderlyingPriceDeterminationMethod()\n"
    "    FIX::UnderlyingPriceDeterminationMethod::UnderlyingPriceDeterminationMethod(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingPriceDeterminationMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingPriceDeterminationMethod *arg1 = (FIX::UnderlyingPriceDeterminationMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingPriceDeterminationMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingPriceDeterminationMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingPriceDeterminationMethod" "', argument " "1"" of type '" "FIX::UnderlyingPriceDeterminationMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingPriceDeterminationMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingPriceDeterminationMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingPriceDeterminationMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoUnderlyingStips__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoUnderlyingStips *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoUnderlyingStips")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoUnderlyingStips *)new FIX::NoUnderlyingStips();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoUnderlyingStips, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingStips__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoUnderlyingStips *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoUnderlyingStips",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoUnderlyingStips" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoUnderlyingStips" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoUnderlyingStips *)new FIX::NoUnderlyingStips((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoUnderlyingStips, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingStips(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoUnderlyingStips__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoUnderlyingStips__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoUnderlyingStips'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoUnderlyingStips::NoUnderlyingStips()\n"
    "    FIX::NoUnderlyingStips::NoUnderlyingStips(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoUnderlyingStips(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoUnderlyingStips *arg1 = (FIX::NoUnderlyingStips *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoUnderlyingStips",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoUnderlyingStips, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoUnderlyingStips" "', argument " "1"" of type '" "FIX::NoUnderlyingStips *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoUnderlyingStips * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoUnderlyingStips_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoUnderlyingStips, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradSesPreCloseTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesPreCloseTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradSesPreCloseTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesPreCloseTime *)new FIX::TradSesPreCloseTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesPreCloseTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesPreCloseTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesPreCloseTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesPreCloseTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TradSesPreCloseTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesPreCloseTime *)new FIX::TradSesPreCloseTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesPreCloseTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesPreCloseTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesPreCloseTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesPreCloseTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesPreCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesPreCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesPreCloseTime *)new FIX::TradSesPreCloseTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesPreCloseTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesPreCloseTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::TradSesPreCloseTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TradSesPreCloseTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesPreCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesPreCloseTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TradSesPreCloseTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesPreCloseTime *)new FIX::TradSesPreCloseTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesPreCloseTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesPreCloseTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradSesPreCloseTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesPreCloseTime__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_TradSesPreCloseTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TradSesPreCloseTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradSesPreCloseTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradSesPreCloseTime::TradSesPreCloseTime()\n"
    "    FIX::TradSesPreCloseTime::TradSesPreCloseTime(bool)\n"
    "    FIX::TradSesPreCloseTime::TradSesPreCloseTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::TradSesPreCloseTime::TradSesPreCloseTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradSesPreCloseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesPreCloseTime *arg1 = (FIX::TradSesPreCloseTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradSesPreCloseTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradSesPreCloseTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradSesPreCloseTime" "', argument " "1"" of type '" "FIX::TradSesPreCloseTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradSesPreCloseTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradSesPreCloseTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradSesPreCloseTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MassCancelRequestType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassCancelRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MassCancelRequestType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassCancelRequestType *)new FIX::MassCancelRequestType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassCancelRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassCancelRequestType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MassCancelRequestType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MassCancelRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassCancelRequestType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassCancelRequestType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassCancelRequestType *)new FIX::MassCancelRequestType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassCancelRequestType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassCancelRequestType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MassCancelRequestType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassCancelRequestType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MassCancelRequestType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MassCancelRequestType::MassCancelRequestType()\n"
    "    FIX::MassCancelRequestType::MassCancelRequestType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MassCancelRequestType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassCancelRequestType *arg1 = (FIX::MassCancelRequestType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MassCancelRequestType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MassCancelRequestType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MassCancelRequestType" "', argument " "1"" of type '" "FIX::MassCancelRequestType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MassCancelRequestType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MassCancelRequestType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MassCancelRequestType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityAltIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecurityAltIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegSecurityAltIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecurityAltIDSource *)new FIX::UnderlyingLegSecurityAltIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecurityAltIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityAltIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegSecurityAltIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegSecurityAltIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecurityAltIDSource *)new FIX::UnderlyingLegSecurityAltIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecurityAltIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityAltIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegSecurityAltIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecurityAltIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegSecurityAltIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegSecurityAltIDSource::UnderlyingLegSecurityAltIDSource()\n"
    "    FIX::UnderlyingLegSecurityAltIDSource::UnderlyingLegSecurityAltIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegSecurityAltIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecurityAltIDSource *arg1 = (FIX::UnderlyingLegSecurityAltIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegSecurityAltIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegSecurityAltIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegSecurityAltIDSource" "', argument " "1"" of type '" "FIX::UnderlyingLegSecurityAltIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegSecurityAltIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingLegSecurityAltIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityAltIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlPartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlPartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlPartyID *)new FIX::SettlPartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlPartyID *)new FIX::SettlPartyID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlPartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlPartyID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlPartyID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlPartyID::SettlPartyID()\n"
    "    FIX::SettlPartyID::SettlPartyID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlPartyID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlPartyID *arg1 = (FIX::SettlPartyID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlPartyID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlPartyID" "', argument " "1"" of type '" "FIX::SettlPartyID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlPartyID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlPartyID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlPartyID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoAffectedOrders__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoAffectedOrders *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoAffectedOrders")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoAffectedOrders *)new FIX::NoAffectedOrders();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoAffectedOrders, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAffectedOrders__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoAffectedOrders *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoAffectedOrders",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoAffectedOrders" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoAffectedOrders" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoAffectedOrders *)new FIX::NoAffectedOrders((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoAffectedOrders, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAffectedOrders(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoAffectedOrders__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoAffectedOrders__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoAffectedOrders'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoAffectedOrders::NoAffectedOrders()\n"
    "    FIX::NoAffectedOrders::NoAffectedOrders(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoAffectedOrders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoAffectedOrders *arg1 = (FIX::NoAffectedOrders *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoAffectedOrders",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoAffectedOrders, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoAffectedOrders" "', argument " "1"" of type '" "FIX::NoAffectedOrders *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoAffectedOrders * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoAffectedOrders_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoAffectedOrders, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CashSettlAgentAcctNum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashSettlAgentAcctNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashSettlAgentAcctNum")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashSettlAgentAcctNum *)new FIX::CashSettlAgentAcctNum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashSettlAgentAcctNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentAcctNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashSettlAgentAcctNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashSettlAgentAcctNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashSettlAgentAcctNum" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashSettlAgentAcctNum" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashSettlAgentAcctNum *)new FIX::CashSettlAgentAcctNum((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashSettlAgentAcctNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentAcctNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashSettlAgentAcctNum__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashSettlAgentAcctNum__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashSettlAgentAcctNum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashSettlAgentAcctNum::CashSettlAgentAcctNum()\n"
    "    FIX::CashSettlAgentAcctNum::CashSettlAgentAcctNum(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashSettlAgentAcctNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashSettlAgentAcctNum *arg1 = (FIX::CashSettlAgentAcctNum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashSettlAgentAcctNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashSettlAgentAcctNum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashSettlAgentAcctNum" "', argument " "1"" of type '" "FIX::CashSettlAgentAcctNum *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashSettlAgentAcctNum * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CashSettlAgentAcctNum_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CashSettlAgentAcctNum, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityMonthYear__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegMaturityMonthYear *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegMaturityMonthYear")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegMaturityMonthYear *)new FIX::UnderlyingLegMaturityMonthYear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityMonthYear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegMaturityMonthYear *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegMaturityMonthYear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegMaturityMonthYear" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegMaturityMonthYear *)new FIX::UnderlyingLegMaturityMonthYear((FIX::MONTHYEAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegMaturityMonthYear, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegMaturityMonthYear(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegMaturityMonthYear__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegMaturityMonthYear__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegMaturityMonthYear'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegMaturityMonthYear::UnderlyingLegMaturityMonthYear()\n"
    "    FIX::UnderlyingLegMaturityMonthYear::UnderlyingLegMaturityMonthYear(FIX::MONTHYEAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegMaturityMonthYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegMaturityMonthYear *arg1 = (FIX::UnderlyingLegMaturityMonthYear *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegMaturityMonthYear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegMaturityMonthYear, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegMaturityMonthYear" "', argument " "1"" of type '" "FIX::UnderlyingLegMaturityMonthYear *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegMaturityMonthYear * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingLegMaturityMonthYear_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingLegMaturityMonthYear, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoLotTypeRules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoLotTypeRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoLotTypeRules")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoLotTypeRules *)new FIX::NoLotTypeRules();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoLotTypeRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLotTypeRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoLotTypeRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoLotTypeRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoLotTypeRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoLotTypeRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoLotTypeRules *)new FIX::NoLotTypeRules((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoLotTypeRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLotTypeRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoLotTypeRules__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoLotTypeRules__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoLotTypeRules'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoLotTypeRules::NoLotTypeRules()\n"
    "    FIX::NoLotTypeRules::NoLotTypeRules(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoLotTypeRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoLotTypeRules *arg1 = (FIX::NoLotTypeRules *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoLotTypeRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoLotTypeRules, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoLotTypeRules" "', argument " "1"" of type '" "FIX::NoLotTypeRules *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoLotTypeRules * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoLotTypeRules_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoLotTypeRules, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoDates__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDates *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoDates")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDates *)new FIX::NoDates();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDates, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDates__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoDates *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoDates",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoDates" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoDates" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDates *)new FIX::NoDates((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDates, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDates(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoDates__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDates__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoDates'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoDates::NoDates()\n"
    "    FIX::NoDates::NoDates(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoDates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDates *arg1 = (FIX::NoDates *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoDates",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoDates, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoDates" "', argument " "1"" of type '" "FIX::NoDates *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoDates * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoDates_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoDates, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CxlRejResponseTo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CxlRejResponseTo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CxlRejResponseTo")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CxlRejResponseTo *)new FIX::CxlRejResponseTo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CxlRejResponseTo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlRejResponseTo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CxlRejResponseTo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CxlRejResponseTo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CxlRejResponseTo" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CxlRejResponseTo" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CxlRejResponseTo *)new FIX::CxlRejResponseTo((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CxlRejResponseTo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlRejResponseTo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CxlRejResponseTo__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CxlRejResponseTo__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CxlRejResponseTo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CxlRejResponseTo::CxlRejResponseTo()\n"
    "    FIX::CxlRejResponseTo::CxlRejResponseTo(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CxlRejResponseTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CxlRejResponseTo *arg1 = (FIX::CxlRejResponseTo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CxlRejResponseTo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CxlRejResponseTo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CxlRejResponseTo" "', argument " "1"" of type '" "FIX::CxlRejResponseTo *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CxlRejResponseTo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CxlRejResponseTo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CxlRejResponseTo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EffectiveTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EffectiveTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EffectiveTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EffectiveTime *)new FIX::EffectiveTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EffectiveTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EffectiveTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EffectiveTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EffectiveTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EffectiveTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EffectiveTime *)new FIX::EffectiveTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EffectiveTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EffectiveTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EffectiveTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EffectiveTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EffectiveTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EffectiveTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EffectiveTime *)new FIX::EffectiveTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EffectiveTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EffectiveTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::EffectiveTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_EffectiveTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EffectiveTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EffectiveTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EffectiveTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EffectiveTime *)new FIX::EffectiveTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EffectiveTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EffectiveTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EffectiveTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EffectiveTime__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_EffectiveTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_EffectiveTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EffectiveTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EffectiveTime::EffectiveTime()\n"
    "    FIX::EffectiveTime::EffectiveTime(bool)\n"
    "    FIX::EffectiveTime::EffectiveTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::EffectiveTime::EffectiveTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EffectiveTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EffectiveTime *arg1 = (FIX::EffectiveTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EffectiveTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EffectiveTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EffectiveTime" "', argument " "1"" of type '" "FIX::EffectiveTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EffectiveTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EffectiveTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EffectiveTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_GrossTradeAmt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::GrossTradeAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_GrossTradeAmt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::GrossTradeAmt *)new FIX::GrossTradeAmt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__GrossTradeAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GrossTradeAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::GrossTradeAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_GrossTradeAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GrossTradeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GrossTradeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::GrossTradeAmt *)new FIX::GrossTradeAmt((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__GrossTradeAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GrossTradeAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_GrossTradeAmt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GrossTradeAmt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GrossTradeAmt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::GrossTradeAmt::GrossTradeAmt()\n"
    "    FIX::GrossTradeAmt::GrossTradeAmt(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GrossTradeAmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::GrossTradeAmt *arg1 = (FIX::GrossTradeAmt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_GrossTradeAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__GrossTradeAmt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GrossTradeAmt" "', argument " "1"" of type '" "FIX::GrossTradeAmt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::GrossTradeAmt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GrossTradeAmt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__GrossTradeAmt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityListDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityListDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityListDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityListDesc *)new FIX::SecurityListDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityListDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityListDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityListDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityListDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityListDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityListDesc *)new FIX::SecurityListDesc((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityListDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityListDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityListDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityListDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityListDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityListDesc::SecurityListDesc()\n"
    "    FIX::SecurityListDesc::SecurityListDesc(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityListDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityListDesc *arg1 = (FIX::SecurityListDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityListDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityListDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityListDesc" "', argument " "1"" of type '" "FIX::SecurityListDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityListDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityListDesc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityListDesc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NotAffectedOrderID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NotAffectedOrderID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NotAffectedOrderID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NotAffectedOrderID *)new FIX::NotAffectedOrderID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NotAffectedOrderID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotAffectedOrderID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NotAffectedOrderID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NotAffectedOrderID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NotAffectedOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NotAffectedOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NotAffectedOrderID *)new FIX::NotAffectedOrderID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NotAffectedOrderID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotAffectedOrderID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NotAffectedOrderID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NotAffectedOrderID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NotAffectedOrderID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NotAffectedOrderID::NotAffectedOrderID()\n"
    "    FIX::NotAffectedOrderID::NotAffectedOrderID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NotAffectedOrderID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NotAffectedOrderID *arg1 = (FIX::NotAffectedOrderID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NotAffectedOrderID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NotAffectedOrderID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NotAffectedOrderID" "', argument " "1"" of type '" "FIX::NotAffectedOrderID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NotAffectedOrderID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NotAffectedOrderID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NotAffectedOrderID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeStrikeValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeStrikeValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeStrikeValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeStrikeValue *)new FIX::DerivativeStrikeValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeStrikeValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikeValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeStrikeValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeStrikeValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeStrikeValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeStrikeValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeStrikeValue *)new FIX::DerivativeStrikeValue((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeStrikeValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikeValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeStrikeValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeStrikeValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeStrikeValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeStrikeValue::DerivativeStrikeValue()\n"
    "    FIX::DerivativeStrikeValue::DerivativeStrikeValue(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeStrikeValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeStrikeValue *arg1 = (FIX::DerivativeStrikeValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeStrikeValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeStrikeValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeStrikeValue" "', argument " "1"" of type '" "FIX::DerivativeStrikeValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeStrikeValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeStrikeValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeStrikeValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoPosAmt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoPosAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoPosAmt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPosAmt *)new FIX::NoPosAmt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPosAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPosAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoPosAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoPosAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoPosAmt" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoPosAmt" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPosAmt *)new FIX::NoPosAmt((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPosAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPosAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoPosAmt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoPosAmt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoPosAmt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoPosAmt::NoPosAmt()\n"
    "    FIX::NoPosAmt::NoPosAmt(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoPosAmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoPosAmt *arg1 = (FIX::NoPosAmt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoPosAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoPosAmt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoPosAmt" "', argument " "1"" of type '" "FIX::NoPosAmt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoPosAmt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoPosAmt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoPosAmt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegCreditRating__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCreditRating *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegCreditRating")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCreditRating *)new FIX::LegCreditRating();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCreditRating, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCreditRating__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegCreditRating *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegCreditRating",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegCreditRating" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegCreditRating" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCreditRating *)new FIX::LegCreditRating((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCreditRating, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCreditRating(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegCreditRating__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCreditRating__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegCreditRating'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegCreditRating::LegCreditRating()\n"
    "    FIX::LegCreditRating::LegCreditRating(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegCreditRating(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCreditRating *arg1 = (FIX::LegCreditRating *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegCreditRating",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegCreditRating, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegCreditRating" "', argument " "1"" of type '" "FIX::LegCreditRating *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegCreditRating * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegCreditRating_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegCreditRating, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BidForwardPoints2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidForwardPoints2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BidForwardPoints2")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidForwardPoints2 *)new FIX::BidForwardPoints2();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidForwardPoints2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidForwardPoints2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BidForwardPoints2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BidForwardPoints2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BidForwardPoints2" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BidForwardPoints2" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidForwardPoints2 *)new FIX::BidForwardPoints2((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidForwardPoints2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidForwardPoints2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BidForwardPoints2__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidForwardPoints2__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BidForwardPoints2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BidForwardPoints2::BidForwardPoints2()\n"
    "    FIX::BidForwardPoints2::BidForwardPoints2(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BidForwardPoints2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidForwardPoints2 *arg1 = (FIX::BidForwardPoints2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BidForwardPoints2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BidForwardPoints2, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BidForwardPoints2" "', argument " "1"" of type '" "FIX::BidForwardPoints2 *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BidForwardPoints2 * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BidForwardPoints2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BidForwardPoints2, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlDate *)new FIX::SettlDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlDate *)new FIX::SettlDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlDate::SettlDate()\n"
    "    FIX::SettlDate::SettlDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlDate *arg1 = (FIX::SettlDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlDate" "', argument " "1"" of type '" "FIX::SettlDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ClientID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClientID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ClientID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClientID *)new FIX::ClientID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClientID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClientID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ClientID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ClientID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClientID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ClientID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClientID *)new FIX::ClientID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClientID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClientID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ClientID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClientID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ClientID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ClientID::ClientID()\n"
    "    FIX::ClientID::ClientID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ClientID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClientID *arg1 = (FIX::ClientID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ClientID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ClientID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClientID" "', argument " "1"" of type '" "FIX::ClientID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ClientID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ClientID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ClientID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_QuoteCancelType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteCancelType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteCancelType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteCancelType *)new FIX::QuoteCancelType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteCancelType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteCancelType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteCancelType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteCancelType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteCancelType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteCancelType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteCancelType *)new FIX::QuoteCancelType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteCancelType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteCancelType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteCancelType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteCancelType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteCancelType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteCancelType::QuoteCancelType()\n"
    "    FIX::QuoteCancelType::QuoteCancelType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteCancelType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteCancelType *arg1 = (FIX::QuoteCancelType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteCancelType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteCancelType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteCancelType" "', argument " "1"" of type '" "FIX::QuoteCancelType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteCancelType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteCancelType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__QuoteCancelType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StipulationType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StipulationType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StipulationType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StipulationType *)new FIX::StipulationType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StipulationType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StipulationType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StipulationType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StipulationType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StipulationType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StipulationType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StipulationType *)new FIX::StipulationType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StipulationType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StipulationType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StipulationType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StipulationType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StipulationType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StipulationType::StipulationType()\n"
    "    FIX::StipulationType::StipulationType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StipulationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StipulationType *arg1 = (FIX::StipulationType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StipulationType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StipulationType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StipulationType" "', argument " "1"" of type '" "FIX::StipulationType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StipulationType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StipulationType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__StipulationType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OutMainCntryUIndex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OutMainCntryUIndex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OutMainCntryUIndex")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OutMainCntryUIndex *)new FIX::OutMainCntryUIndex();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OutMainCntryUIndex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutMainCntryUIndex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OutMainCntryUIndex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OutMainCntryUIndex",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OutMainCntryUIndex" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OutMainCntryUIndex" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OutMainCntryUIndex *)new FIX::OutMainCntryUIndex((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OutMainCntryUIndex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OutMainCntryUIndex(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OutMainCntryUIndex__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OutMainCntryUIndex__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OutMainCntryUIndex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OutMainCntryUIndex::OutMainCntryUIndex()\n"
    "    FIX::OutMainCntryUIndex::OutMainCntryUIndex(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OutMainCntryUIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OutMainCntryUIndex *arg1 = (FIX::OutMainCntryUIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OutMainCntryUIndex",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OutMainCntryUIndex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OutMainCntryUIndex" "', argument " "1"" of type '" "FIX::OutMainCntryUIndex *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OutMainCntryUIndex * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OutMainCntryUIndex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OutMainCntryUIndex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegSettlmntTyp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSettlmntTyp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSettlmntTyp")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSettlmntTyp *)new FIX::LegSettlmntTyp();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSettlmntTyp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlmntTyp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSettlmntTyp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSettlmntTyp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSettlmntTyp" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSettlmntTyp" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSettlmntTyp *)new FIX::LegSettlmntTyp((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSettlmntTyp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlmntTyp(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSettlmntTyp__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSettlmntTyp__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSettlmntTyp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSettlmntTyp::LegSettlmntTyp()\n"
    "    FIX::LegSettlmntTyp::LegSettlmntTyp(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSettlmntTyp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSettlmntTyp *arg1 = (FIX::LegSettlmntTyp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSettlmntTyp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSettlmntTyp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSettlmntTyp" "', argument " "1"" of type '" "FIX::LegSettlmntTyp *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSettlmntTyp * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegSettlmntTyp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegSettlmntTyp, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeNTPositionLimit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeNTPositionLimit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeNTPositionLimit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeNTPositionLimit *)new FIX::DerivativeNTPositionLimit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeNTPositionLimit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeNTPositionLimit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeNTPositionLimit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeNTPositionLimit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeNTPositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeNTPositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeNTPositionLimit *)new FIX::DerivativeNTPositionLimit((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeNTPositionLimit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeNTPositionLimit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeNTPositionLimit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeNTPositionLimit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeNTPositionLimit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeNTPositionLimit::DerivativeNTPositionLimit()\n"
    "    FIX::DerivativeNTPositionLimit::DerivativeNTPositionLimit(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeNTPositionLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeNTPositionLimit *arg1 = (FIX::DerivativeNTPositionLimit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeNTPositionLimit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeNTPositionLimit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeNTPositionLimit" "', argument " "1"" of type '" "FIX::DerivativeNTPositionLimit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeNTPositionLimit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeNTPositionLimit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeNTPositionLimit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PriceQuoteMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceQuoteMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PriceQuoteMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceQuoteMethod *)new FIX::PriceQuoteMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceQuoteMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceQuoteMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PriceQuoteMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PriceQuoteMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PriceQuoteMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PriceQuoteMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceQuoteMethod *)new FIX::PriceQuoteMethod((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceQuoteMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceQuoteMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PriceQuoteMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceQuoteMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PriceQuoteMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PriceQuoteMethod::PriceQuoteMethod()\n"
    "    FIX::PriceQuoteMethod::PriceQuoteMethod(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PriceQuoteMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceQuoteMethod *arg1 = (FIX::PriceQuoteMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PriceQuoteMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PriceQuoteMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PriceQuoteMethod" "', argument " "1"" of type '" "FIX::PriceQuoteMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PriceQuoteMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PriceQuoteMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PriceQuoteMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LowLimitPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LowLimitPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LowLimitPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LowLimitPrice *)new FIX::LowLimitPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LowLimitPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LowLimitPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LowLimitPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LowLimitPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LowLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LowLimitPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LowLimitPrice *)new FIX::LowLimitPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LowLimitPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LowLimitPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LowLimitPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LowLimitPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LowLimitPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LowLimitPrice::LowLimitPrice()\n"
    "    FIX::LowLimitPrice::LowLimitPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LowLimitPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LowLimitPrice *arg1 = (FIX::LowLimitPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LowLimitPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LowLimitPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LowLimitPrice" "', argument " "1"" of type '" "FIX::LowLimitPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LowLimitPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LowLimitPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LowLimitPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegUnitOfMeasure__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegUnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegUnitOfMeasure")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegUnitOfMeasure *)new FIX::LegUnitOfMeasure();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegUnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegUnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegUnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegUnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegUnitOfMeasure *)new FIX::LegUnitOfMeasure((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegUnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegUnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegUnitOfMeasure__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegUnitOfMeasure__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegUnitOfMeasure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegUnitOfMeasure::LegUnitOfMeasure()\n"
    "    FIX::LegUnitOfMeasure::LegUnitOfMeasure(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegUnitOfMeasure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegUnitOfMeasure *arg1 = (FIX::LegUnitOfMeasure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegUnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegUnitOfMeasure, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegUnitOfMeasure" "', argument " "1"" of type '" "FIX::LegUnitOfMeasure *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegUnitOfMeasure * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegUnitOfMeasure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegUnitOfMeasure, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SessionRejectReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SessionRejectReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SessionRejectReason *)new FIX::SessionRejectReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SessionRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SessionRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SessionRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SessionRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SessionRejectReason *)new FIX::SessionRejectReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SessionRejectReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SessionRejectReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SessionRejectReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SessionRejectReason::SessionRejectReason()\n"
    "    FIX::SessionRejectReason::SessionRejectReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SessionRejectReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionRejectReason *arg1 = (FIX::SessionRejectReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SessionRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionRejectReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SessionRejectReason" "', argument " "1"" of type '" "FIX::SessionRejectReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionRejectReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SessionRejectReason_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SessionRejectReason, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DeliveryType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeliveryType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DeliveryType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeliveryType *)new FIX::DeliveryType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeliveryType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliveryType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DeliveryType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DeliveryType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeliveryType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeliveryType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeliveryType *)new FIX::DeliveryType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeliveryType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliveryType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DeliveryType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeliveryType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DeliveryType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DeliveryType::DeliveryType()\n"
    "    FIX::DeliveryType::DeliveryType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DeliveryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeliveryType *arg1 = (FIX::DeliveryType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DeliveryType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DeliveryType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeliveryType" "', argument " "1"" of type '" "FIX::DeliveryType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DeliveryType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DeliveryType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DeliveryType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocPrice *)new FIX::AllocPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocPrice *)new FIX::AllocPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocPrice::AllocPrice()\n"
    "    FIX::AllocPrice::AllocPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocPrice *arg1 = (FIX::AllocPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocPrice" "', argument " "1"" of type '" "FIX::AllocPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoBidComponents__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoBidComponents *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoBidComponents")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoBidComponents *)new FIX::NoBidComponents();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoBidComponents, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoBidComponents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoBidComponents *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoBidComponents",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoBidComponents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoBidComponents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoBidComponents *)new FIX::NoBidComponents((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoBidComponents, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoBidComponents(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoBidComponents__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoBidComponents__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoBidComponents'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoBidComponents::NoBidComponents()\n"
    "    FIX::NoBidComponents::NoBidComponents(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoBidComponents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoBidComponents *arg1 = (FIX::NoBidComponents *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoBidComponents",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoBidComponents, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoBidComponents" "', argument " "1"" of type '" "FIX::NoBidComponents *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoBidComponents * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoBidComponents_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoBidComponents, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_QuoteQualifier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteQualifier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteQualifier")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteQualifier *)new FIX::QuoteQualifier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteQualifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteQualifier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteQualifier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteQualifier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteQualifier" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteQualifier" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteQualifier *)new FIX::QuoteQualifier((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteQualifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteQualifier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteQualifier__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteQualifier__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteQualifier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteQualifier::QuoteQualifier()\n"
    "    FIX::QuoteQualifier::QuoteQualifier(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteQualifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteQualifier *arg1 = (FIX::QuoteQualifier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteQualifier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteQualifier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteQualifier" "', argument " "1"" of type '" "FIX::QuoteQualifier *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteQualifier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteQualifier_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__QuoteQualifier, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Scope__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Scope *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Scope")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Scope *)new FIX::Scope();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Scope, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Scope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Scope *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Scope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MULTIPLECHARVALUE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Scope" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Scope" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLECHARVALUE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Scope *)new FIX::Scope((FIX::MULTIPLECHARVALUE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Scope, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Scope(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Scope__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MULTIPLECHARVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Scope__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Scope'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Scope::Scope()\n"
    "    FIX::Scope::Scope(FIX::MULTIPLECHARVALUE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Scope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Scope *arg1 = (FIX::Scope *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Scope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Scope, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Scope" "', argument " "1"" of type '" "FIX::Scope *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Scope * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Scope_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Scope, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoSecurityAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoSecurityAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSecurityAltID *)new FIX::NoSecurityAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSecurityAltID *)new FIX::NoSecurityAltID((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoSecurityAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSecurityAltID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoSecurityAltID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoSecurityAltID::NoSecurityAltID()\n"
    "    FIX::NoSecurityAltID::NoSecurityAltID(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoSecurityAltID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSecurityAltID *arg1 = (FIX::NoSecurityAltID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoSecurityAltID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoSecurityAltID" "', argument " "1"" of type '" "FIX::NoSecurityAltID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoSecurityAltID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoSecurityAltID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoSecurityAltID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RootPartySubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RootPartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RootPartySubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RootPartySubID *)new FIX::RootPartySubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RootPartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RootPartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RootPartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RootPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RootPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RootPartySubID *)new FIX::RootPartySubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RootPartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RootPartySubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RootPartySubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RootPartySubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RootPartySubID::RootPartySubID()\n"
    "    FIX::RootPartySubID::RootPartySubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RootPartySubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RootPartySubID *arg1 = (FIX::RootPartySubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RootPartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RootPartySubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RootPartySubID" "', argument " "1"" of type '" "FIX::RootPartySubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RootPartySubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RootPartySubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RootPartySubID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DeliverToLocationID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeliverToLocationID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DeliverToLocationID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeliverToLocationID *)new FIX::DeliverToLocationID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeliverToLocationID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliverToLocationID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DeliverToLocationID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DeliverToLocationID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeliverToLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeliverToLocationID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeliverToLocationID *)new FIX::DeliverToLocationID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeliverToLocationID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeliverToLocationID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DeliverToLocationID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeliverToLocationID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DeliverToLocationID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DeliverToLocationID::DeliverToLocationID()\n"
    "    FIX::DeliverToLocationID::DeliverToLocationID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DeliverToLocationID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeliverToLocationID *arg1 = (FIX::DeliverToLocationID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DeliverToLocationID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DeliverToLocationID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeliverToLocationID" "', argument " "1"" of type '" "FIX::DeliverToLocationID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DeliverToLocationID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DeliverToLocationID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DeliverToLocationID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DeleteReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeleteReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DeleteReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeleteReason *)new FIX::DeleteReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeleteReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeleteReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DeleteReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DeleteReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeleteReason" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeleteReason" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeleteReason *)new FIX::DeleteReason((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeleteReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeleteReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DeleteReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeleteReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DeleteReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DeleteReason::DeleteReason()\n"
    "    FIX::DeleteReason::DeleteReason(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DeleteReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeleteReason *arg1 = (FIX::DeleteReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DeleteReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DeleteReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeleteReason" "', argument " "1"" of type '" "FIX::DeleteReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DeleteReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DeleteReason_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DeleteReason, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BidSpotRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidSpotRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BidSpotRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidSpotRate *)new FIX::BidSpotRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidSpotRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidSpotRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BidSpotRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BidSpotRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BidSpotRate" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BidSpotRate" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidSpotRate *)new FIX::BidSpotRate((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidSpotRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidSpotRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BidSpotRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidSpotRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BidSpotRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BidSpotRate::BidSpotRate()\n"
    "    FIX::BidSpotRate::BidSpotRate(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BidSpotRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidSpotRate *arg1 = (FIX::BidSpotRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BidSpotRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BidSpotRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BidSpotRate" "', argument " "1"" of type '" "FIX::BidSpotRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BidSpotRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BidSpotRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BidSpotRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Nested4PartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested4PartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested4PartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested4PartyID *)new FIX::Nested4PartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested4PartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested4PartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested4PartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested4PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested4PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested4PartyID *)new FIX::Nested4PartyID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested4PartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested4PartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested4PartyID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested4PartyID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested4PartyID::Nested4PartyID()\n"
    "    FIX::Nested4PartyID::Nested4PartyID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested4PartyID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested4PartyID *arg1 = (FIX::Nested4PartyID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested4PartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested4PartyID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested4PartyID" "', argument " "1"" of type '" "FIX::Nested4PartyID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested4PartyID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Nested4PartyID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Nested4PartyID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_InViewOfCommon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InViewOfCommon *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InViewOfCommon")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InViewOfCommon *)new FIX::InViewOfCommon();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InViewOfCommon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InViewOfCommon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InViewOfCommon *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InViewOfCommon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InViewOfCommon" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InViewOfCommon" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InViewOfCommon *)new FIX::InViewOfCommon((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InViewOfCommon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InViewOfCommon(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InViewOfCommon__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InViewOfCommon__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InViewOfCommon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InViewOfCommon::InViewOfCommon()\n"
    "    FIX::InViewOfCommon::InViewOfCommon(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InViewOfCommon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InViewOfCommon *arg1 = (FIX::InViewOfCommon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InViewOfCommon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InViewOfCommon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InViewOfCommon" "', argument " "1"" of type '" "FIX::InViewOfCommon *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InViewOfCommon * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InViewOfCommon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__InViewOfCommon, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingSettlPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSettlPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSettlPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSettlPrice *)new FIX::UnderlyingSettlPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSettlPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSettlPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSettlPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSettlPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSettlPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSettlPrice *)new FIX::UnderlyingSettlPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSettlPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSettlPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSettlPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSettlPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSettlPrice::UnderlyingSettlPrice()\n"
    "    FIX::UnderlyingSettlPrice::UnderlyingSettlPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSettlPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSettlPrice *arg1 = (FIX::UnderlyingSettlPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSettlPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSettlPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSettlPrice" "', argument " "1"" of type '" "FIX::UnderlyingSettlPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSettlPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingSettlPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingSettlPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RegistRejReasonText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistRejReasonText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RegistRejReasonText")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistRejReasonText *)new FIX::RegistRejReasonText();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistRejReasonText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistRejReasonText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RegistRejReasonText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RegistRejReasonText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegistRejReasonText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegistRejReasonText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistRejReasonText *)new FIX::RegistRejReasonText((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistRejReasonText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistRejReasonText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RegistRejReasonText__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistRejReasonText__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RegistRejReasonText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RegistRejReasonText::RegistRejReasonText()\n"
    "    FIX::RegistRejReasonText::RegistRejReasonText(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RegistRejReasonText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistRejReasonText *arg1 = (FIX::RegistRejReasonText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RegistRejReasonText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RegistRejReasonText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegistRejReasonText" "', argument " "1"" of type '" "FIX::RegistRejReasonText *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RegistRejReasonText * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RegistRejReasonText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RegistRejReasonText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoSides__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSides *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoSides")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSides *)new FIX::NoSides();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSides, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSides__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoSides *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoSides",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoSides" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoSides" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSides *)new FIX::NoSides((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSides, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSides(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoSides__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSides__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoSides'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoSides::NoSides()\n"
    "    FIX::NoSides::NoSides(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoSides(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSides *arg1 = (FIX::NoSides *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoSides",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoSides, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoSides" "', argument " "1"" of type '" "FIX::NoSides *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoSides * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoSides_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoSides, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegAllocAccount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegAllocAccount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegAllocAccount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegAllocAccount *)new FIX::LegAllocAccount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegAllocAccount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocAccount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegAllocAccount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegAllocAccount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegAllocAccount" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegAllocAccount" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegAllocAccount *)new FIX::LegAllocAccount((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegAllocAccount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocAccount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegAllocAccount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegAllocAccount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegAllocAccount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegAllocAccount::LegAllocAccount()\n"
    "    FIX::LegAllocAccount::LegAllocAccount(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegAllocAccount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegAllocAccount *arg1 = (FIX::LegAllocAccount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegAllocAccount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegAllocAccount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegAllocAccount" "', argument " "1"" of type '" "FIX::LegAllocAccount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegAllocAccount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegAllocAccount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegAllocAccount, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegSecurityDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSecurityDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecurityDesc *)new FIX::LegSecurityDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSecurityDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSecurityDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecurityDesc *)new FIX::LegSecurityDesc((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecurityDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSecurityDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecurityDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSecurityDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSecurityDesc::LegSecurityDesc()\n"
    "    FIX::LegSecurityDesc::LegSecurityDesc(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSecurityDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecurityDesc *arg1 = (FIX::LegSecurityDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSecurityDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSecurityDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSecurityDesc" "', argument " "1"" of type '" "FIX::LegSecurityDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSecurityDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegSecurityDesc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegSecurityDesc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ClOrdLinkID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClOrdLinkID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ClOrdLinkID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClOrdLinkID *)new FIX::ClOrdLinkID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClOrdLinkID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClOrdLinkID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ClOrdLinkID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ClOrdLinkID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClOrdLinkID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ClOrdLinkID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClOrdLinkID *)new FIX::ClOrdLinkID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClOrdLinkID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClOrdLinkID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ClOrdLinkID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClOrdLinkID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ClOrdLinkID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ClOrdLinkID::ClOrdLinkID()\n"
    "    FIX::ClOrdLinkID::ClOrdLinkID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ClOrdLinkID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClOrdLinkID *arg1 = (FIX::ClOrdLinkID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ClOrdLinkID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ClOrdLinkID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClOrdLinkID" "', argument " "1"" of type '" "FIX::ClOrdLinkID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ClOrdLinkID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ClOrdLinkID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ClOrdLinkID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OrigSendingTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigSendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrigSendingTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigSendingTime *)new FIX::OrigSendingTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigSendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigSendingTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrigSendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrigSendingTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OrigSendingTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigSendingTime *)new FIX::OrigSendingTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigSendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigSendingTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrigSendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrigSendingTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrigSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrigSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigSendingTime *)new FIX::OrigSendingTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigSendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigSendingTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::OrigSendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_OrigSendingTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrigSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrigSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OrigSendingTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigSendingTime *)new FIX::OrigSendingTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigSendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigSendingTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrigSendingTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigSendingTime__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_OrigSendingTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_OrigSendingTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrigSendingTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrigSendingTime::OrigSendingTime()\n"
    "    FIX::OrigSendingTime::OrigSendingTime(bool)\n"
    "    FIX::OrigSendingTime::OrigSendingTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::OrigSendingTime::OrigSendingTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrigSendingTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigSendingTime *arg1 = (FIX::OrigSendingTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrigSendingTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrigSendingTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrigSendingTime" "', argument " "1"" of type '" "FIX::OrigSendingTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrigSendingTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrigSendingTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrigSendingTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncodedLegIssuerLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedLegIssuerLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedLegIssuerLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedLegIssuerLen *)new FIX::EncodedLegIssuerLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedLegIssuerLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegIssuerLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedLegIssuerLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedLegIssuerLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedLegIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedLegIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedLegIssuerLen *)new FIX::EncodedLegIssuerLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedLegIssuerLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedLegIssuerLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedLegIssuerLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedLegIssuerLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedLegIssuerLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedLegIssuerLen::EncodedLegIssuerLen()\n"
    "    FIX::EncodedLegIssuerLen::EncodedLegIssuerLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedLegIssuerLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedLegIssuerLen *arg1 = (FIX::EncodedLegIssuerLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedLegIssuerLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedLegIssuerLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedLegIssuerLen" "', argument " "1"" of type '" "FIX::EncodedLegIssuerLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedLegIssuerLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncodedLegIssuerLen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedLegIssuerLen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OrderID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrderID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderID *)new FIX::OrderID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrderID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrderID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderID *)new FIX::OrderID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrderID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrderID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrderID::OrderID()\n"
    "    FIX::OrderID::OrderID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrderID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderID *arg1 = (FIX::OrderID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrderID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrderID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrderID" "', argument " "1"" of type '" "FIX::OrderID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrderID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrderID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrderID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityType *)new FIX::SecurityType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityType *)new FIX::SecurityType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityType::SecurityType()\n"
    "    FIX::SecurityType::SecurityType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityType *arg1 = (FIX::SecurityType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityType" "', argument " "1"" of type '" "FIX::SecurityType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RoundingDirection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RoundingDirection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RoundingDirection")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RoundingDirection *)new FIX::RoundingDirection();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RoundingDirection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoundingDirection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RoundingDirection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RoundingDirection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RoundingDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RoundingDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RoundingDirection *)new FIX::RoundingDirection((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RoundingDirection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoundingDirection(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RoundingDirection__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RoundingDirection__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RoundingDirection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RoundingDirection::RoundingDirection()\n"
    "    FIX::RoundingDirection::RoundingDirection(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RoundingDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RoundingDirection *arg1 = (FIX::RoundingDirection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RoundingDirection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RoundingDirection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RoundingDirection" "', argument " "1"" of type '" "FIX::RoundingDirection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RoundingDirection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RoundingDirection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RoundingDirection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FillExecID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FillExecID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FillExecID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FillExecID *)new FIX::FillExecID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FillExecID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillExecID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FillExecID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FillExecID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FillExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FillExecID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FillExecID *)new FIX::FillExecID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FillExecID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillExecID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FillExecID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FillExecID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FillExecID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FillExecID::FillExecID()\n"
    "    FIX::FillExecID::FillExecID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FillExecID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FillExecID *arg1 = (FIX::FillExecID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FillExecID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FillExecID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FillExecID" "', argument " "1"" of type '" "FIX::FillExecID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FillExecID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FillExecID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FillExecID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoEvents__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoEvents *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoEvents")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoEvents *)new FIX::NoEvents();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoEvents, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoEvents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoEvents *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoEvents",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoEvents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoEvents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoEvents *)new FIX::NoEvents((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoEvents, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoEvents(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoEvents__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoEvents__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoEvents'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoEvents::NoEvents()\n"
    "    FIX::NoEvents::NoEvents(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoEvents *arg1 = (FIX::NoEvents *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoEvents",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoEvents, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoEvents" "', argument " "1"" of type '" "FIX::NoEvents *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoEvents * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoEvents_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoEvents, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RoundLot__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RoundLot *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RoundLot")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RoundLot *)new FIX::RoundLot();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RoundLot, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoundLot__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RoundLot *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RoundLot",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RoundLot" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RoundLot" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RoundLot *)new FIX::RoundLot((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RoundLot, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoundLot(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RoundLot__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RoundLot__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RoundLot'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RoundLot::RoundLot()\n"
    "    FIX::RoundLot::RoundLot(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RoundLot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RoundLot *arg1 = (FIX::RoundLot *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RoundLot",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RoundLot, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RoundLot" "', argument " "1"" of type '" "FIX::RoundLot *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RoundLot * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RoundLot_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RoundLot, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MDEntrySize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntrySize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDEntrySize")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntrySize *)new FIX::MDEntrySize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntrySize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntrySize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDEntrySize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDEntrySize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDEntrySize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDEntrySize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntrySize *)new FIX::MDEntrySize((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntrySize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntrySize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDEntrySize__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntrySize__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDEntrySize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDEntrySize::MDEntrySize()\n"
    "    FIX::MDEntrySize::MDEntrySize(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDEntrySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntrySize *arg1 = (FIX::MDEntrySize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDEntrySize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDEntrySize, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDEntrySize" "', argument " "1"" of type '" "FIX::MDEntrySize *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDEntrySize * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MDEntrySize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MDEntrySize, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncodedIssuerLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedIssuerLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedIssuerLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedIssuerLen *)new FIX::EncodedIssuerLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedIssuerLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedIssuerLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedIssuerLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedIssuerLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedIssuerLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedIssuerLen *)new FIX::EncodedIssuerLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedIssuerLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedIssuerLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedIssuerLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedIssuerLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedIssuerLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedIssuerLen::EncodedIssuerLen()\n"
    "    FIX::EncodedIssuerLen::EncodedIssuerLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedIssuerLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedIssuerLen *arg1 = (FIX::EncodedIssuerLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedIssuerLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedIssuerLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedIssuerLen" "', argument " "1"" of type '" "FIX::EncodedIssuerLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedIssuerLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncodedIssuerLen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedIssuerLen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativePriceUnitOfMeasureQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativePriceUnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativePriceUnitOfMeasureQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativePriceUnitOfMeasureQty *)new FIX::DerivativePriceUnitOfMeasureQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePriceUnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativePriceUnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativePriceUnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativePriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativePriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativePriceUnitOfMeasureQty *)new FIX::DerivativePriceUnitOfMeasureQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePriceUnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativePriceUnitOfMeasureQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativePriceUnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativePriceUnitOfMeasureQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativePriceUnitOfMeasureQty::DerivativePriceUnitOfMeasureQty()\n"
    "    FIX::DerivativePriceUnitOfMeasureQty::DerivativePriceUnitOfMeasureQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativePriceUnitOfMeasureQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativePriceUnitOfMeasureQty *arg1 = (FIX::DerivativePriceUnitOfMeasureQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativePriceUnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasureQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativePriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::DerivativePriceUnitOfMeasureQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativePriceUnitOfMeasureQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativePriceUnitOfMeasureQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativePriceUnitOfMeasureQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TimeUnit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TimeUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TimeUnit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TimeUnit *)new FIX::TimeUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TimeUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TimeUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TimeUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TimeUnit *)new FIX::TimeUnit((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TimeUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TimeUnit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TimeUnit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TimeUnit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TimeUnit::TimeUnit()\n"
    "    FIX::TimeUnit::TimeUnit(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TimeUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TimeUnit *arg1 = (FIX::TimeUnit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TimeUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TimeUnit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeUnit" "', argument " "1"" of type '" "FIX::TimeUnit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TimeUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TimeUnit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TimeUnit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TotNoOrders__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoOrders *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotNoOrders")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoOrders *)new FIX::TotNoOrders();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoOrders, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoOrders__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotNoOrders *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotNoOrders",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotNoOrders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotNoOrders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoOrders *)new FIX::TotNoOrders((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoOrders, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoOrders(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotNoOrders__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoOrders__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotNoOrders'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotNoOrders::TotNoOrders()\n"
    "    FIX::TotNoOrders::TotNoOrders(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotNoOrders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoOrders *arg1 = (FIX::TotNoOrders *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotNoOrders",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotNoOrders, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotNoOrders" "', argument " "1"" of type '" "FIX::TotNoOrders *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotNoOrders * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TotNoOrders_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TotNoOrders, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegSwapType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSwapType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSwapType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSwapType *)new FIX::LegSwapType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSwapType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSwapType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSwapType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSwapType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSwapType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSwapType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSwapType *)new FIX::LegSwapType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSwapType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSwapType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSwapType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSwapType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSwapType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSwapType::LegSwapType()\n"
    "    FIX::LegSwapType::LegSwapType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSwapType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSwapType *arg1 = (FIX::LegSwapType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSwapType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSwapType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSwapType" "', argument " "1"" of type '" "FIX::LegSwapType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSwapType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegSwapType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegSwapType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_IOITransType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOITransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IOITransType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOITransType *)new FIX::IOITransType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOITransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOITransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IOITransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IOITransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOITransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IOITransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOITransType *)new FIX::IOITransType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOITransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOITransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IOITransType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOITransType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IOITransType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IOITransType::IOITransType()\n"
    "    FIX::IOITransType::IOITransType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IOITransType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOITransType *arg1 = (FIX::IOITransType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IOITransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IOITransType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOITransType" "', argument " "1"" of type '" "FIX::IOITransType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IOITransType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IOITransType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__IOITransType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RawDataLength__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RawDataLength *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RawDataLength")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RawDataLength *)new FIX::RawDataLength();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RawDataLength, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawDataLength__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RawDataLength *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RawDataLength",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RawDataLength" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RawDataLength" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RawDataLength *)new FIX::RawDataLength((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RawDataLength, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RawDataLength(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RawDataLength__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RawDataLength__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RawDataLength'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RawDataLength::RawDataLength()\n"
    "    FIX::RawDataLength::RawDataLength(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RawDataLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RawDataLength *arg1 = (FIX::RawDataLength *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RawDataLength",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RawDataLength, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RawDataLength" "', argument " "1"" of type '" "FIX::RawDataLength *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RawDataLength * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RawDataLength_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RawDataLength, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSecurityType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecurityType *)new FIX::UnderlyingSecurityType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSecurityType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSecurityType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecurityType *)new FIX::UnderlyingSecurityType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecurityType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSecurityType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecurityType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSecurityType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSecurityType::UnderlyingSecurityType()\n"
    "    FIX::UnderlyingSecurityType::UnderlyingSecurityType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSecurityType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecurityType *arg1 = (FIX::UnderlyingSecurityType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSecurityType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSecurityType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSecurityType" "', argument " "1"" of type '" "FIX::UnderlyingSecurityType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSecurityType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingSecurityType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingSecurityType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegSecurityAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecurityAltID *)new FIX::UnderlyingLegSecurityAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecurityAltID *)new FIX::UnderlyingLegSecurityAltID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegSecurityAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecurityAltID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegSecurityAltID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegSecurityAltID::UnderlyingLegSecurityAltID()\n"
    "    FIX::UnderlyingLegSecurityAltID::UnderlyingLegSecurityAltID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegSecurityAltID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecurityAltID *arg1 = (FIX::UnderlyingLegSecurityAltID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegSecurityAltID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegSecurityAltID" "', argument " "1"" of type '" "FIX::UnderlyingLegSecurityAltID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegSecurityAltID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingLegSecurityAltID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityAltID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityReportID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityReportID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityReportID *)new FIX::SecurityReportID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityReportID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityReportID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityReportID *)new FIX::SecurityReportID((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityReportID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityReportID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityReportID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityReportID::SecurityReportID()\n"
    "    FIX::SecurityReportID::SecurityReportID(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityReportID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityReportID *arg1 = (FIX::SecurityReportID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityReportID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityReportID" "', argument " "1"" of type '" "FIX::SecurityReportID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityReportID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityReportID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityReportID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TotNumReports__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNumReports *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotNumReports")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNumReports *)new FIX::TotNumReports();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNumReports, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNumReports__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotNumReports *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotNumReports",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotNumReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotNumReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNumReports *)new FIX::TotNumReports((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNumReports, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNumReports(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotNumReports__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNumReports__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotNumReports'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotNumReports::TotNumReports()\n"
    "    FIX::TotNumReports::TotNumReports(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotNumReports(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNumReports *arg1 = (FIX::TotNumReports *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotNumReports",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotNumReports, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotNumReports" "', argument " "1"" of type '" "FIX::TotNumReports *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotNumReports * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TotNumReports_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TotNumReports, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TotalNumPosReports__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalNumPosReports *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotalNumPosReports")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalNumPosReports *)new FIX::TotalNumPosReports();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalNumPosReports, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNumPosReports__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotalNumPosReports *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotalNumPosReports",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotalNumPosReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotalNumPosReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalNumPosReports *)new FIX::TotalNumPosReports((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalNumPosReports, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNumPosReports(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotalNumPosReports__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalNumPosReports__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotalNumPosReports'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotalNumPosReports::TotalNumPosReports()\n"
    "    FIX::TotalNumPosReports::TotalNumPosReports(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotalNumPosReports(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalNumPosReports *arg1 = (FIX::TotalNumPosReports *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotalNumPosReports",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotalNumPosReports, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotalNumPosReports" "', argument " "1"" of type '" "FIX::TotalNumPosReports *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotalNumPosReports * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TotalNumPosReports_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TotalNumPosReports, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityReqID *)new FIX::SecurityReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityReqID *)new FIX::SecurityReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityReqID::SecurityReqID()\n"
    "    FIX::SecurityReqID::SecurityReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityReqID *arg1 = (FIX::SecurityReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityReqID" "', argument " "1"" of type '" "FIX::SecurityReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityReqID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityReqID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PosReqResult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosReqResult *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PosReqResult")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosReqResult *)new FIX::PosReqResult();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosReqResult, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqResult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PosReqResult *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PosReqResult",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PosReqResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PosReqResult" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosReqResult *)new FIX::PosReqResult((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosReqResult, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqResult(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PosReqResult__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosReqResult__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PosReqResult'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PosReqResult::PosReqResult()\n"
    "    FIX::PosReqResult::PosReqResult(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PosReqResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosReqResult *arg1 = (FIX::PosReqResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PosReqResult",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PosReqResult, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PosReqResult" "', argument " "1"" of type '" "FIX::PosReqResult *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PosReqResult * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PosReqResult_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PosReqResult, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegOfferForwardPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegOfferForwardPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegOfferForwardPoints")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegOfferForwardPoints *)new FIX::LegOfferForwardPoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegOfferForwardPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOfferForwardPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegOfferForwardPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegOfferForwardPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegOfferForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegOfferForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegOfferForwardPoints *)new FIX::LegOfferForwardPoints((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegOfferForwardPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOfferForwardPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegOfferForwardPoints__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegOfferForwardPoints__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegOfferForwardPoints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegOfferForwardPoints::LegOfferForwardPoints()\n"
    "    FIX::LegOfferForwardPoints::LegOfferForwardPoints(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegOfferForwardPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegOfferForwardPoints *arg1 = (FIX::LegOfferForwardPoints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegOfferForwardPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegOfferForwardPoints, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegOfferForwardPoints" "', argument " "1"" of type '" "FIX::LegOfferForwardPoints *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegOfferForwardPoints * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegOfferForwardPoints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegOfferForwardPoints, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessCurr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllowableOneSidednessCurr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllowableOneSidednessCurr")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllowableOneSidednessCurr *)new FIX::AllowableOneSidednessCurr();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllowableOneSidednessCurr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessCurr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllowableOneSidednessCurr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllowableOneSidednessCurr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllowableOneSidednessCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllowableOneSidednessCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllowableOneSidednessCurr *)new FIX::AllowableOneSidednessCurr((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllowableOneSidednessCurr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessCurr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllowableOneSidednessCurr__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllowableOneSidednessCurr__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllowableOneSidednessCurr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllowableOneSidednessCurr::AllowableOneSidednessCurr()\n"
    "    FIX::AllowableOneSidednessCurr::AllowableOneSidednessCurr(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllowableOneSidednessCurr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllowableOneSidednessCurr *arg1 = (FIX::AllowableOneSidednessCurr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllowableOneSidednessCurr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllowableOneSidednessCurr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllowableOneSidednessCurr" "', argument " "1"" of type '" "FIX::AllowableOneSidednessCurr *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllowableOneSidednessCurr * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllowableOneSidednessCurr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllowableOneSidednessCurr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AffectedOrderID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AffectedOrderID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AffectedOrderID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AffectedOrderID *)new FIX::AffectedOrderID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AffectedOrderID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AffectedOrderID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AffectedOrderID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AffectedOrderID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AffectedOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AffectedOrderID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AffectedOrderID *)new FIX::AffectedOrderID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AffectedOrderID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AffectedOrderID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AffectedOrderID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AffectedOrderID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AffectedOrderID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AffectedOrderID::AffectedOrderID()\n"
    "    FIX::AffectedOrderID::AffectedOrderID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AffectedOrderID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AffectedOrderID *arg1 = (FIX::AffectedOrderID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AffectedOrderID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AffectedOrderID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AffectedOrderID" "', argument " "1"" of type '" "FIX::AffectedOrderID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AffectedOrderID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AffectedOrderID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AffectedOrderID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingCountryOfIssue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCountryOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingCountryOfIssue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCountryOfIssue *)new FIX::UnderlyingCountryOfIssue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCountryOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCountryOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::COUNTRY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingCountryOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingCountryOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__COUNTRY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingCountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingCountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::COUNTRY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCountryOfIssue *)new FIX::UnderlyingCountryOfIssue((FIX::COUNTRY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCountryOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCountryOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingCountryOfIssue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__COUNTRY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCountryOfIssue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingCountryOfIssue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingCountryOfIssue::UnderlyingCountryOfIssue()\n"
    "    FIX::UnderlyingCountryOfIssue::UnderlyingCountryOfIssue(FIX::COUNTRY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingCountryOfIssue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCountryOfIssue *arg1 = (FIX::UnderlyingCountryOfIssue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingCountryOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingCountryOfIssue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingCountryOfIssue" "', argument " "1"" of type '" "FIX::UnderlyingCountryOfIssue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingCountryOfIssue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingCountryOfIssue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingCountryOfIssue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingRepurchaseRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingRepurchaseRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingRepurchaseRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingRepurchaseRate *)new FIX::UnderlyingRepurchaseRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingRepurchaseRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRepurchaseRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingRepurchaseRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingRepurchaseRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingRepurchaseRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingRepurchaseRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingRepurchaseRate *)new FIX::UnderlyingRepurchaseRate((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingRepurchaseRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRepurchaseRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingRepurchaseRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingRepurchaseRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingRepurchaseRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingRepurchaseRate::UnderlyingRepurchaseRate()\n"
    "    FIX::UnderlyingRepurchaseRate::UnderlyingRepurchaseRate(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingRepurchaseRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingRepurchaseRate *arg1 = (FIX::UnderlyingRepurchaseRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingRepurchaseRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingRepurchaseRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingRepurchaseRate" "', argument " "1"" of type '" "FIX::UnderlyingRepurchaseRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingRepurchaseRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingRepurchaseRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingRepurchaseRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LastMsgSeqNumProcessed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastMsgSeqNumProcessed *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastMsgSeqNumProcessed")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastMsgSeqNumProcessed *)new FIX::LastMsgSeqNumProcessed();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastMsgSeqNumProcessed, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastMsgSeqNumProcessed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastMsgSeqNumProcessed *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastMsgSeqNumProcessed",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SEQNUM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastMsgSeqNumProcessed" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastMsgSeqNumProcessed" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastMsgSeqNumProcessed *)new FIX::LastMsgSeqNumProcessed((FIX::SEQNUM const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastMsgSeqNumProcessed, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastMsgSeqNumProcessed(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastMsgSeqNumProcessed__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastMsgSeqNumProcessed__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastMsgSeqNumProcessed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastMsgSeqNumProcessed::LastMsgSeqNumProcessed()\n"
    "    FIX::LastMsgSeqNumProcessed::LastMsgSeqNumProcessed(FIX::SEQNUM const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastMsgSeqNumProcessed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastMsgSeqNumProcessed *arg1 = (FIX::LastMsgSeqNumProcessed *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastMsgSeqNumProcessed",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastMsgSeqNumProcessed, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastMsgSeqNumProcessed" "', argument " "1"" of type '" "FIX::LastMsgSeqNumProcessed *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastMsgSeqNumProcessed * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LastMsgSeqNumProcessed_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LastMsgSeqNumProcessed, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingCFICode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCFICode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingCFICode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCFICode *)new FIX::UnderlyingCFICode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCFICode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCFICode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingCFICode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingCFICode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCFICode *)new FIX::UnderlyingCFICode((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCFICode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCFICode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingCFICode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCFICode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingCFICode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingCFICode::UnderlyingCFICode()\n"
    "    FIX::UnderlyingCFICode::UnderlyingCFICode(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingCFICode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCFICode *arg1 = (FIX::UnderlyingCFICode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingCFICode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingCFICode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingCFICode" "', argument " "1"" of type '" "FIX::UnderlyingCFICode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingCFICode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingCFICode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingCFICode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeOptAttribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeOptAttribute *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeOptAttribute")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeOptAttribute *)new FIX::DerivativeOptAttribute();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeOptAttribute, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeOptAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeOptAttribute *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeOptAttribute",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeOptAttribute *)new FIX::DerivativeOptAttribute((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeOptAttribute, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeOptAttribute(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeOptAttribute__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeOptAttribute__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeOptAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeOptAttribute::DerivativeOptAttribute()\n"
    "    FIX::DerivativeOptAttribute::DerivativeOptAttribute(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeOptAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeOptAttribute *arg1 = (FIX::DerivativeOptAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeOptAttribute",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeOptAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeOptAttribute" "', argument " "1"" of type '" "FIX::DerivativeOptAttribute *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeOptAttribute * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeOptAttribute_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeOptAttribute, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PegSecurityID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegSecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PegSecurityID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegSecurityID *)new FIX::PegSecurityID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegSecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PegSecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PegSecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PegSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PegSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegSecurityID *)new FIX::PegSecurityID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegSecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PegSecurityID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegSecurityID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PegSecurityID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PegSecurityID::PegSecurityID()\n"
    "    FIX::PegSecurityID::PegSecurityID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PegSecurityID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegSecurityID *arg1 = (FIX::PegSecurityID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PegSecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PegSecurityID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PegSecurityID" "', argument " "1"" of type '" "FIX::PegSecurityID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PegSecurityID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PegSecurityID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PegSecurityID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HostCrossID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HostCrossID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HostCrossID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HostCrossID *)new FIX::HostCrossID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HostCrossID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HostCrossID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::HostCrossID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HostCrossID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HostCrossID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HostCrossID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HostCrossID *)new FIX::HostCrossID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HostCrossID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HostCrossID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_HostCrossID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HostCrossID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HostCrossID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::HostCrossID::HostCrossID()\n"
    "    FIX::HostCrossID::HostCrossID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HostCrossID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HostCrossID *arg1 = (FIX::HostCrossID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HostCrossID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__HostCrossID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HostCrossID" "', argument " "1"" of type '" "FIX::HostCrossID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::HostCrossID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HostCrossID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__HostCrossID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExecInstValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecInstValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExecInstValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecInstValue *)new FIX::ExecInstValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecInstValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecInstValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExecInstValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExecInstValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExecInstValue" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExecInstValue" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecInstValue *)new FIX::ExecInstValue((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecInstValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecInstValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExecInstValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecInstValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExecInstValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExecInstValue::ExecInstValue()\n"
    "    FIX::ExecInstValue::ExecInstValue(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExecInstValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecInstValue *arg1 = (FIX::ExecInstValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExecInstValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExecInstValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExecInstValue" "', argument " "1"" of type '" "FIX::ExecInstValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExecInstValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExecInstValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ExecInstValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeOptPayAmount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeOptPayAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeOptPayAmount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeOptPayAmount *)new FIX::DerivativeOptPayAmount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeOptPayAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeOptPayAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeOptPayAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeOptPayAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeOptPayAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeOptPayAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeOptPayAmount *)new FIX::DerivativeOptPayAmount((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeOptPayAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeOptPayAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeOptPayAmount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeOptPayAmount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeOptPayAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeOptPayAmount::DerivativeOptPayAmount()\n"
    "    FIX::DerivativeOptPayAmount::DerivativeOptPayAmount(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeOptPayAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeOptPayAmount *arg1 = (FIX::DerivativeOptPayAmount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeOptPayAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeOptPayAmount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeOptPayAmount" "', argument " "1"" of type '" "FIX::DerivativeOptPayAmount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeOptPayAmount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeOptPayAmount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeOptPayAmount, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingCouponRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCouponRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingCouponRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCouponRate *)new FIX::UnderlyingCouponRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCouponRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCouponRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingCouponRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingCouponRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCouponRate *)new FIX::UnderlyingCouponRate((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCouponRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCouponRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingCouponRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCouponRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingCouponRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingCouponRate::UnderlyingCouponRate()\n"
    "    FIX::UnderlyingCouponRate::UnderlyingCouponRate(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingCouponRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCouponRate *arg1 = (FIX::UnderlyingCouponRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingCouponRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingCouponRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingCouponRate" "', argument " "1"" of type '" "FIX::UnderlyingCouponRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingCouponRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingCouponRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingCouponRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlInstMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstMode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlInstMode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstMode *)new FIX::SettlInstMode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstMode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlInstMode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlInstMode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlInstMode" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlInstMode" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstMode *)new FIX::SettlInstMode((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstMode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstMode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlInstMode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstMode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlInstMode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlInstMode::SettlInstMode()\n"
    "    FIX::SettlInstMode::SettlInstMode(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlInstMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstMode *arg1 = (FIX::SettlInstMode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlInstMode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlInstMode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlInstMode" "', argument " "1"" of type '" "FIX::SettlInstMode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlInstMode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlInstMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlInstMode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityAltIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityAltIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityAltIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityAltIDSource *)new FIX::SecurityAltIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityAltIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityAltIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityAltIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityAltIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityAltIDSource *)new FIX::SecurityAltIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityAltIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityAltIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityAltIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityAltIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityAltIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityAltIDSource::SecurityAltIDSource()\n"
    "    FIX::SecurityAltIDSource::SecurityAltIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityAltIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityAltIDSource *arg1 = (FIX::SecurityAltIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityAltIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityAltIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityAltIDSource" "', argument " "1"" of type '" "FIX::SecurityAltIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityAltIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityAltIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityAltIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PreviouslyReported__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PreviouslyReported *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PreviouslyReported")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PreviouslyReported *)new FIX::PreviouslyReported();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PreviouslyReported, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PreviouslyReported__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PreviouslyReported *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PreviouslyReported",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PreviouslyReported" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PreviouslyReported" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PreviouslyReported *)new FIX::PreviouslyReported((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PreviouslyReported, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PreviouslyReported(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PreviouslyReported__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PreviouslyReported__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PreviouslyReported'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PreviouslyReported::PreviouslyReported()\n"
    "    FIX::PreviouslyReported::PreviouslyReported(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PreviouslyReported(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PreviouslyReported *arg1 = (FIX::PreviouslyReported *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PreviouslyReported",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PreviouslyReported, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PreviouslyReported" "', argument " "1"" of type '" "FIX::PreviouslyReported *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PreviouslyReported * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PreviouslyReported_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PreviouslyReported, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RptSys__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RptSys *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RptSys")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RptSys *)new FIX::RptSys();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RptSys, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RptSys__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RptSys *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RptSys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RptSys" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RptSys" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RptSys *)new FIX::RptSys((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RptSys, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RptSys(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RptSys__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RptSys__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RptSys'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RptSys::RptSys()\n"
    "    FIX::RptSys::RptSys(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RptSys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RptSys *arg1 = (FIX::RptSys *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RptSys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RptSys, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RptSys" "', argument " "1"" of type '" "FIX::RptSys *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RptSys * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RptSys_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RptSys, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoNested2PartySubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNested2PartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoNested2PartySubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNested2PartySubIDs *)new FIX::NoNested2PartySubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNested2PartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested2PartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoNested2PartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoNested2PartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoNested2PartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoNested2PartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNested2PartySubIDs *)new FIX::NoNested2PartySubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNested2PartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested2PartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoNested2PartySubIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNested2PartySubIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoNested2PartySubIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoNested2PartySubIDs::NoNested2PartySubIDs()\n"
    "    FIX::NoNested2PartySubIDs::NoNested2PartySubIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoNested2PartySubIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNested2PartySubIDs *arg1 = (FIX::NoNested2PartySubIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoNested2PartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoNested2PartySubIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoNested2PartySubIDs" "', argument " "1"" of type '" "FIX::NoNested2PartySubIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoNested2PartySubIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoNested2PartySubIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoNested2PartySubIDs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RefAllocID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefAllocID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefAllocID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefAllocID *)new FIX::RefAllocID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefAllocID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefAllocID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefAllocID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefAllocID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefAllocID *)new FIX::RefAllocID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefAllocID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefAllocID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefAllocID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefAllocID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefAllocID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefAllocID::RefAllocID()\n"
    "    FIX::RefAllocID::RefAllocID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefAllocID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefAllocID *arg1 = (FIX::RefAllocID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefAllocID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefAllocID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefAllocID" "', argument " "1"" of type '" "FIX::RefAllocID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefAllocID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RefAllocID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RefAllocID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DefOfferSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DefOfferSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DefOfferSize")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DefOfferSize *)new FIX::DefOfferSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DefOfferSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefOfferSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DefOfferSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DefOfferSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DefOfferSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefOfferSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DefOfferSize *)new FIX::DefOfferSize((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DefOfferSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefOfferSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DefOfferSize__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefOfferSize__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DefOfferSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DefOfferSize::DefOfferSize()\n"
    "    FIX::DefOfferSize::DefOfferSize(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DefOfferSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DefOfferSize *arg1 = (FIX::DefOfferSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DefOfferSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DefOfferSize, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefOfferSize" "', argument " "1"" of type '" "FIX::DefOfferSize *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DefOfferSize * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefOfferSize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DefOfferSize, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ProductComplex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ProductComplex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ProductComplex")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ProductComplex *)new FIX::ProductComplex();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ProductComplex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProductComplex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ProductComplex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ProductComplex",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ProductComplex" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ProductComplex" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ProductComplex *)new FIX::ProductComplex((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ProductComplex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProductComplex(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ProductComplex__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ProductComplex__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ProductComplex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ProductComplex::ProductComplex()\n"
    "    FIX::ProductComplex::ProductComplex(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ProductComplex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ProductComplex *arg1 = (FIX::ProductComplex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ProductComplex",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ProductComplex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ProductComplex" "', argument " "1"" of type '" "FIX::ProductComplex *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ProductComplex * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ProductComplex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ProductComplex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CustOrderHandlingInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CustOrderHandlingInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CustOrderHandlingInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CustOrderHandlingInst *)new FIX::CustOrderHandlingInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CustOrderHandlingInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustOrderHandlingInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLESTRINGVALUE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CustOrderHandlingInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CustOrderHandlingInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustOrderHandlingInst" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustOrderHandlingInst" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLESTRINGVALUE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CustOrderHandlingInst *)new FIX::CustOrderHandlingInst((FIX::MULTIPLESTRINGVALUE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CustOrderHandlingInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustOrderHandlingInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CustOrderHandlingInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CustOrderHandlingInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CustOrderHandlingInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CustOrderHandlingInst::CustOrderHandlingInst()\n"
    "    FIX::CustOrderHandlingInst::CustOrderHandlingInst(FIX::MULTIPLESTRINGVALUE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CustOrderHandlingInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CustOrderHandlingInst *arg1 = (FIX::CustOrderHandlingInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CustOrderHandlingInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CustOrderHandlingInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CustOrderHandlingInst" "', argument " "1"" of type '" "FIX::CustOrderHandlingInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CustOrderHandlingInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CustOrderHandlingInst_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CustOrderHandlingInst, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MDPriceLevel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDPriceLevel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDPriceLevel")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDPriceLevel *)new FIX::MDPriceLevel();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDPriceLevel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDPriceLevel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDPriceLevel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDPriceLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDPriceLevel" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDPriceLevel" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDPriceLevel *)new FIX::MDPriceLevel((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDPriceLevel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDPriceLevel(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDPriceLevel__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDPriceLevel__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDPriceLevel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDPriceLevel::MDPriceLevel()\n"
    "    FIX::MDPriceLevel::MDPriceLevel(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDPriceLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDPriceLevel *arg1 = (FIX::MDPriceLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDPriceLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDPriceLevel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDPriceLevel" "', argument " "1"" of type '" "FIX::MDPriceLevel *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDPriceLevel * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MDPriceLevel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MDPriceLevel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegOptionRatio__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegOptionRatio *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegOptionRatio")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegOptionRatio *)new FIX::LegOptionRatio();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegOptionRatio, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOptionRatio__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegOptionRatio *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegOptionRatio",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegOptionRatio" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegOptionRatio" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegOptionRatio *)new FIX::LegOptionRatio((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegOptionRatio, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOptionRatio(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegOptionRatio__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegOptionRatio__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegOptionRatio'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegOptionRatio::LegOptionRatio()\n"
    "    FIX::LegOptionRatio::LegOptionRatio(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegOptionRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegOptionRatio *arg1 = (FIX::LegOptionRatio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegOptionRatio",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegOptionRatio, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegOptionRatio" "', argument " "1"" of type '" "FIX::LegOptionRatio *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegOptionRatio * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegOptionRatio_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegOptionRatio, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityStatus *)new FIX::SecurityStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityStatus" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityStatus" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityStatus *)new FIX::SecurityStatus((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityStatus::SecurityStatus()\n"
    "    FIX::SecurityStatus::SecurityStatus(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityStatus *arg1 = (FIX::SecurityStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityStatus" "', argument " "1"" of type '" "FIX::SecurityStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegRefID *)new FIX::LegRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegRefID *)new FIX::LegRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegRefID::LegRefID()\n"
    "    FIX::LegRefID::LegRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegRefID *arg1 = (FIX::LegRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegRefID" "', argument " "1"" of type '" "FIX::LegRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegRefID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegRefID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DividendYield__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DividendYield *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DividendYield")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DividendYield *)new FIX::DividendYield();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DividendYield, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DividendYield__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DividendYield *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DividendYield",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DividendYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DividendYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DividendYield *)new FIX::DividendYield((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DividendYield, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DividendYield(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DividendYield__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DividendYield__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DividendYield'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DividendYield::DividendYield()\n"
    "    FIX::DividendYield::DividendYield(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DividendYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DividendYield *arg1 = (FIX::DividendYield *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DividendYield",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DividendYield, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DividendYield" "', argument " "1"" of type '" "FIX::DividendYield *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DividendYield * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DividendYield_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DividendYield, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartySubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrumentPartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeInstrumentPartySubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrumentPartySubIDType *)new FIX::DerivativeInstrumentPartySubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrumentPartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeInstrumentPartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeInstrumentPartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrumentPartySubIDType *)new FIX::DerivativeInstrumentPartySubIDType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrumentPartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeInstrumentPartySubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrumentPartySubIDType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeInstrumentPartySubIDType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeInstrumentPartySubIDType::DerivativeInstrumentPartySubIDType()\n"
    "    FIX::DerivativeInstrumentPartySubIDType::DerivativeInstrumentPartySubIDType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeInstrumentPartySubIDType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrumentPartySubIDType *arg1 = (FIX::DerivativeInstrumentPartySubIDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeInstrumentPartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeInstrumentPartySubIDType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeInstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::DerivativeInstrumentPartySubIDType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeInstrumentPartySubIDType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeInstrumentPartySubIDType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeInstrumentPartySubIDType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EndStrikePxRange__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EndStrikePxRange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EndStrikePxRange")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EndStrikePxRange *)new FIX::EndStrikePxRange();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EndStrikePxRange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndStrikePxRange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EndStrikePxRange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EndStrikePxRange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EndStrikePxRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EndStrikePxRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EndStrikePxRange *)new FIX::EndStrikePxRange((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EndStrikePxRange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndStrikePxRange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EndStrikePxRange__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EndStrikePxRange__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EndStrikePxRange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EndStrikePxRange::EndStrikePxRange()\n"
    "    FIX::EndStrikePxRange::EndStrikePxRange(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EndStrikePxRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EndStrikePxRange *arg1 = (FIX::EndStrikePxRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EndStrikePxRange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EndStrikePxRange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EndStrikePxRange" "', argument " "1"" of type '" "FIX::EndStrikePxRange *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EndStrikePxRange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EndStrikePxRange_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EndStrikePxRange, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DisplayQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DisplayQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DisplayQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DisplayQty *)new FIX::DisplayQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DisplayQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DisplayQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DisplayQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DisplayQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DisplayQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DisplayQty *)new FIX::DisplayQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DisplayQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DisplayQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DisplayQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DisplayQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DisplayQty::DisplayQty()\n"
    "    FIX::DisplayQty::DisplayQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DisplayQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DisplayQty *arg1 = (FIX::DisplayQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DisplayQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DisplayQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DisplayQty" "', argument " "1"" of type '" "FIX::DisplayQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DisplayQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DisplayQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DisplayQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegSecuritySubType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecuritySubType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSecuritySubType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecuritySubType *)new FIX::LegSecuritySubType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecuritySubType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecuritySubType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSecuritySubType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSecuritySubType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecuritySubType *)new FIX::LegSecuritySubType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecuritySubType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecuritySubType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSecuritySubType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecuritySubType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSecuritySubType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSecuritySubType::LegSecuritySubType()\n"
    "    FIX::LegSecuritySubType::LegSecuritySubType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSecuritySubType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecuritySubType *arg1 = (FIX::LegSecuritySubType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSecuritySubType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSecuritySubType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSecuritySubType" "', argument " "1"" of type '" "FIX::LegSecuritySubType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSecuritySubType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegSecuritySubType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegSecuritySubType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ProcessCode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ProcessCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ProcessCode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ProcessCode *)new FIX::ProcessCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ProcessCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProcessCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ProcessCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ProcessCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ProcessCode" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ProcessCode" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ProcessCode *)new FIX::ProcessCode((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ProcessCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProcessCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ProcessCode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ProcessCode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ProcessCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ProcessCode::ProcessCode()\n"
    "    FIX::ProcessCode::ProcessCode(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ProcessCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ProcessCode *arg1 = (FIX::ProcessCode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ProcessCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ProcessCode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ProcessCode" "', argument " "1"" of type '" "FIX::ProcessCode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ProcessCode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ProcessCode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ProcessCode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExecInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExecInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecInst *)new FIX::ExecInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExecInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExecInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MULTIPLECHARVALUE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExecInst" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExecInst" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLECHARVALUE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecInst *)new FIX::ExecInst((FIX::MULTIPLECHARVALUE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExecInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MULTIPLECHARVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExecInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExecInst::ExecInst()\n"
    "    FIX::ExecInst::ExecInst(FIX::MULTIPLECHARVALUE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExecInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecInst *arg1 = (FIX::ExecInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExecInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExecInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExecInst" "', argument " "1"" of type '" "FIX::ExecInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExecInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExecInst_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ExecInst, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradSesEndTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesEndTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradSesEndTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesEndTime *)new FIX::TradSesEndTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesEndTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesEndTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesEndTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesEndTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TradSesEndTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesEndTime *)new FIX::TradSesEndTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesEndTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesEndTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesEndTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesEndTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesEndTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesEndTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesEndTime *)new FIX::TradSesEndTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesEndTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesEndTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::TradSesEndTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TradSesEndTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesEndTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesEndTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TradSesEndTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesEndTime *)new FIX::TradSesEndTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesEndTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesEndTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradSesEndTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesEndTime__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_TradSesEndTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TradSesEndTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradSesEndTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradSesEndTime::TradSesEndTime()\n"
    "    FIX::TradSesEndTime::TradSesEndTime(bool)\n"
    "    FIX::TradSesEndTime::TradSesEndTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::TradSesEndTime::TradSesEndTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradSesEndTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesEndTime *arg1 = (FIX::TradSesEndTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradSesEndTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradSesEndTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradSesEndTime" "', argument " "1"" of type '" "FIX::TradSesEndTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradSesEndTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradSesEndTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradSesEndTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OrigTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrigTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigTime *)new FIX::OrigTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrigTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrigTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OrigTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigTime *)new FIX::OrigTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrigTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrigTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrigTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrigTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigTime *)new FIX::OrigTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::OrigTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_OrigTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrigTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrigTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OrigTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigTime *)new FIX::OrigTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrigTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigTime__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_OrigTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_OrigTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrigTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrigTime::OrigTime()\n"
    "    FIX::OrigTime::OrigTime(bool)\n"
    "    FIX::OrigTime::OrigTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::OrigTime::OrigTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrigTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigTime *arg1 = (FIX::OrigTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrigTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrigTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrigTime" "', argument " "1"" of type '" "FIX::OrigTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrigTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrigTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrigTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExecValuationPoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecValuationPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExecValuationPoint")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecValuationPoint *)new FIX::ExecValuationPoint();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecValuationPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecValuationPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExecValuationPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExecValuationPoint",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExecValuationPoint" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecValuationPoint *)new FIX::ExecValuationPoint(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecValuationPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecValuationPoint__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExecValuationPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExecValuationPoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExecValuationPoint" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExecValuationPoint" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecValuationPoint *)new FIX::ExecValuationPoint((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecValuationPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecValuationPoint__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::ExecValuationPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ExecValuationPoint",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExecValuationPoint" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExecValuationPoint" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExecValuationPoint" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecValuationPoint *)new FIX::ExecValuationPoint((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecValuationPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecValuationPoint(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExecValuationPoint__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecValuationPoint__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_ExecValuationPoint__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ExecValuationPoint__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExecValuationPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExecValuationPoint::ExecValuationPoint()\n"
    "    FIX::ExecValuationPoint::ExecValuationPoint(bool)\n"
    "    FIX::ExecValuationPoint::ExecValuationPoint(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::ExecValuationPoint::ExecValuationPoint(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExecValuationPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecValuationPoint *arg1 = (FIX::ExecValuationPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExecValuationPoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExecValuationPoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExecValuationPoint" "', argument " "1"" of type '" "FIX::ExecValuationPoint *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExecValuationPoint * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExecValuationPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ExecValuationPoint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExecType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExecType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecType *)new FIX::ExecType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExecType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExecType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExecType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExecType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecType *)new FIX::ExecType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExecType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExecType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExecType::ExecType()\n"
    "    FIX::ExecType::ExecType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExecType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecType *arg1 = (FIX::ExecType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExecType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExecType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExecType" "', argument " "1"" of type '" "FIX::ExecType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExecType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExecType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ExecType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Nested4PartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested4PartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested4PartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested4PartyRole *)new FIX::Nested4PartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested4PartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested4PartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested4PartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested4PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested4PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested4PartyRole *)new FIX::Nested4PartyRole((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested4PartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested4PartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested4PartyRole__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested4PartyRole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested4PartyRole::Nested4PartyRole()\n"
    "    FIX::Nested4PartyRole::Nested4PartyRole(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested4PartyRole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested4PartyRole *arg1 = (FIX::Nested4PartyRole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested4PartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested4PartyRole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested4PartyRole" "', argument " "1"" of type '" "FIX::Nested4PartyRole *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested4PartyRole * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Nested4PartyRole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Nested4PartyRole, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MultilegModel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MultilegModel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MultilegModel")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MultilegModel *)new FIX::MultilegModel();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MultilegModel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultilegModel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MultilegModel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MultilegModel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MultilegModel" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MultilegModel" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MultilegModel *)new FIX::MultilegModel((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MultilegModel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultilegModel(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MultilegModel__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MultilegModel__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MultilegModel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MultilegModel::MultilegModel()\n"
    "    FIX::MultilegModel::MultilegModel(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MultilegModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MultilegModel *arg1 = (FIX::MultilegModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MultilegModel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MultilegModel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MultilegModel" "', argument " "1"" of type '" "FIX::MultilegModel *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MultilegModel * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MultilegModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MultilegModel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityGroup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityGroup *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityGroup")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityGroup *)new FIX::SecurityGroup();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityGroup, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityGroup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityGroup *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityGroup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityGroup" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityGroup" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityGroup *)new FIX::SecurityGroup((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityGroup, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityGroup(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityGroup__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityGroup__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityGroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityGroup::SecurityGroup()\n"
    "    FIX::SecurityGroup::SecurityGroup(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityGroup *arg1 = (FIX::SecurityGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityGroup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityGroup, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityGroup" "', argument " "1"" of type '" "FIX::SecurityGroup *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityGroup * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityGroup_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityGroup, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EventType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EventType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EventType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EventType *)new FIX::EventType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EventType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EventType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EventType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EventType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EventType *)new FIX::EventType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EventType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EventType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EventType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EventType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EventType::EventType()\n"
    "    FIX::EventType::EventType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EventType *arg1 = (FIX::EventType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EventType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EventType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventType" "', argument " "1"" of type '" "FIX::EventType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EventType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EventType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EventType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradeAllocIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeAllocIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeAllocIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeAllocIndicator *)new FIX::TradeAllocIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeAllocIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeAllocIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeAllocIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeAllocIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeAllocIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeAllocIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeAllocIndicator *)new FIX::TradeAllocIndicator((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeAllocIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeAllocIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeAllocIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeAllocIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeAllocIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeAllocIndicator::TradeAllocIndicator()\n"
    "    FIX::TradeAllocIndicator::TradeAllocIndicator(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeAllocIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeAllocIndicator *arg1 = (FIX::TradeAllocIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeAllocIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeAllocIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeAllocIndicator" "', argument " "1"" of type '" "FIX::TradeAllocIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeAllocIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradeAllocIndicator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradeAllocIndicator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_YieldCalcDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::YieldCalcDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_YieldCalcDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::YieldCalcDate *)new FIX::YieldCalcDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__YieldCalcDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldCalcDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::YieldCalcDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_YieldCalcDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YieldCalcDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YieldCalcDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::YieldCalcDate *)new FIX::YieldCalcDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__YieldCalcDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldCalcDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_YieldCalcDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YieldCalcDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_YieldCalcDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::YieldCalcDate::YieldCalcDate()\n"
    "    FIX::YieldCalcDate::YieldCalcDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YieldCalcDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::YieldCalcDate *arg1 = (FIX::YieldCalcDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_YieldCalcDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__YieldCalcDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YieldCalcDate" "', argument " "1"" of type '" "FIX::YieldCalcDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::YieldCalcDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YieldCalcDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__YieldCalcDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ValueOfFutures__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ValueOfFutures *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ValueOfFutures")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ValueOfFutures *)new FIX::ValueOfFutures();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ValueOfFutures, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValueOfFutures__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ValueOfFutures *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ValueOfFutures",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ValueOfFutures" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ValueOfFutures" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ValueOfFutures *)new FIX::ValueOfFutures((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ValueOfFutures, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValueOfFutures(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ValueOfFutures__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ValueOfFutures__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ValueOfFutures'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ValueOfFutures::ValueOfFutures()\n"
    "    FIX::ValueOfFutures::ValueOfFutures(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ValueOfFutures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ValueOfFutures *arg1 = (FIX::ValueOfFutures *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ValueOfFutures",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ValueOfFutures, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ValueOfFutures" "', argument " "1"" of type '" "FIX::ValueOfFutures *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ValueOfFutures * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ValueOfFutures_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ValueOfFutures, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegSide__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSide *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSide")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSide *)new FIX::LegSide();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSide, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSide__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSide *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSide",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSide" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSide" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSide *)new FIX::LegSide((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSide, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSide(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSide__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSide__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSide'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSide::LegSide()\n"
    "    FIX::LegSide::LegSide(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSide *arg1 = (FIX::LegSide *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSide",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSide, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSide" "', argument " "1"" of type '" "FIX::LegSide *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSide * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegSide_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegSide, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UserStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UserStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UserStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UserStatus *)new FIX::UserStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UserStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UserStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UserStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UserStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UserStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UserStatus *)new FIX::UserStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UserStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UserStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UserStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UserStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UserStatus::UserStatus()\n"
    "    FIX::UserStatus::UserStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UserStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UserStatus *arg1 = (FIX::UserStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UserStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UserStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UserStatus" "', argument " "1"" of type '" "FIX::UserStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UserStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UserStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UserStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SideValue1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideValue1 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideValue1")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideValue1 *)new FIX::SideValue1();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideValue1, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideValue1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideValue1 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideValue1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideValue1" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideValue1" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideValue1 *)new FIX::SideValue1((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideValue1, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideValue1(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideValue1__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideValue1__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideValue1'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideValue1::SideValue1()\n"
    "    FIX::SideValue1::SideValue1(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideValue1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideValue1 *arg1 = (FIX::SideValue1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideValue1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideValue1, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideValue1" "', argument " "1"" of type '" "FIX::SideValue1 *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideValue1 * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SideValue1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SideValue1, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CxlQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CxlQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CxlQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CxlQty *)new FIX::CxlQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CxlQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CxlQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CxlQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CxlQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CxlQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CxlQty *)new FIX::CxlQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CxlQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CxlQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CxlQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CxlQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CxlQty::CxlQty()\n"
    "    FIX::CxlQty::CxlQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CxlQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CxlQty *arg1 = (FIX::CxlQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CxlQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CxlQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CxlQty" "', argument " "1"" of type '" "FIX::CxlQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CxlQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CxlQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CxlQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityResponseID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityResponseID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityResponseID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityResponseID *)new FIX::SecurityResponseID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityResponseID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityResponseID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityResponseID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityResponseID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityResponseID *)new FIX::SecurityResponseID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityResponseID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityResponseID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityResponseID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityResponseID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityResponseID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityResponseID::SecurityResponseID()\n"
    "    FIX::SecurityResponseID::SecurityResponseID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityResponseID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityResponseID *arg1 = (FIX::SecurityResponseID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityResponseID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityResponseID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityResponseID" "', argument " "1"" of type '" "FIX::SecurityResponseID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityResponseID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityResponseID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityResponseID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_InstrRegistry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrRegistry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InstrRegistry")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrRegistry *)new FIX::InstrRegistry();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrRegistry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrRegistry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InstrRegistry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InstrRegistry",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrRegistry *)new FIX::InstrRegistry((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrRegistry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrRegistry(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InstrRegistry__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrRegistry__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InstrRegistry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InstrRegistry::InstrRegistry()\n"
    "    FIX::InstrRegistry::InstrRegistry(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InstrRegistry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrRegistry *arg1 = (FIX::InstrRegistry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InstrRegistry",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InstrRegistry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InstrRegistry" "', argument " "1"" of type '" "FIX::InstrRegistry *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InstrRegistry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InstrRegistry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__InstrRegistry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StreamAsgnRptID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StreamAsgnRptID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StreamAsgnRptID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StreamAsgnRptID *)new FIX::StreamAsgnRptID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StreamAsgnRptID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnRptID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StreamAsgnRptID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StreamAsgnRptID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StreamAsgnRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StreamAsgnRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StreamAsgnRptID *)new FIX::StreamAsgnRptID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StreamAsgnRptID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnRptID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StreamAsgnRptID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StreamAsgnRptID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StreamAsgnRptID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StreamAsgnRptID::StreamAsgnRptID()\n"
    "    FIX::StreamAsgnRptID::StreamAsgnRptID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StreamAsgnRptID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StreamAsgnRptID *arg1 = (FIX::StreamAsgnRptID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StreamAsgnRptID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StreamAsgnRptID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StreamAsgnRptID" "', argument " "1"" of type '" "FIX::StreamAsgnRptID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StreamAsgnRptID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StreamAsgnRptID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__StreamAsgnRptID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OrderDelayUnit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderDelayUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrderDelayUnit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderDelayUnit *)new FIX::OrderDelayUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderDelayUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderDelayUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrderDelayUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrderDelayUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrderDelayUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrderDelayUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderDelayUnit *)new FIX::OrderDelayUnit((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderDelayUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderDelayUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrderDelayUnit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderDelayUnit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrderDelayUnit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrderDelayUnit::OrderDelayUnit()\n"
    "    FIX::OrderDelayUnit::OrderDelayUnit(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrderDelayUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderDelayUnit *arg1 = (FIX::OrderDelayUnit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrderDelayUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrderDelayUnit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrderDelayUnit" "', argument " "1"" of type '" "FIX::OrderDelayUnit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrderDelayUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrderDelayUnit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrderDelayUnit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegCurrencyRatio__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCurrencyRatio *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegCurrencyRatio")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCurrencyRatio *)new FIX::LegCurrencyRatio();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCurrencyRatio, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCurrencyRatio__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegCurrencyRatio *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegCurrencyRatio",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegCurrencyRatio" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegCurrencyRatio" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCurrencyRatio *)new FIX::LegCurrencyRatio((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCurrencyRatio, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCurrencyRatio(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegCurrencyRatio__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCurrencyRatio__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegCurrencyRatio'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegCurrencyRatio::LegCurrencyRatio()\n"
    "    FIX::LegCurrencyRatio::LegCurrencyRatio(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegCurrencyRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCurrencyRatio *arg1 = (FIX::LegCurrencyRatio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegCurrencyRatio",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegCurrencyRatio, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegCurrencyRatio" "', argument " "1"" of type '" "FIX::LegCurrencyRatio *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegCurrencyRatio * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegCurrencyRatio_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegCurrencyRatio, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EndTickPriceRange__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EndTickPriceRange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EndTickPriceRange")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EndTickPriceRange *)new FIX::EndTickPriceRange();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EndTickPriceRange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndTickPriceRange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EndTickPriceRange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EndTickPriceRange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EndTickPriceRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EndTickPriceRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EndTickPriceRange *)new FIX::EndTickPriceRange((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EndTickPriceRange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndTickPriceRange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EndTickPriceRange__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EndTickPriceRange__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EndTickPriceRange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EndTickPriceRange::EndTickPriceRange()\n"
    "    FIX::EndTickPriceRange::EndTickPriceRange(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EndTickPriceRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EndTickPriceRange *arg1 = (FIX::EndTickPriceRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EndTickPriceRange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EndTickPriceRange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EndTickPriceRange" "', argument " "1"" of type '" "FIX::EndTickPriceRange *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EndTickPriceRange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EndTickPriceRange_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EndTickPriceRange, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CollReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollReqID *)new FIX::CollReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollReqID *)new FIX::CollReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollReqID::CollReqID()\n"
    "    FIX::CollReqID::CollReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollReqID *arg1 = (FIX::CollReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollReqID" "', argument " "1"" of type '" "FIX::CollReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CollReqID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CollReqID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegPool__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegPool *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegPool")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegPool *)new FIX::LegPool();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegPool, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPool__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegPool *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegPool",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegPool" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegPool" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegPool *)new FIX::LegPool((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegPool, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPool(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegPool__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegPool__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegPool'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegPool::LegPool()\n"
    "    FIX::LegPool::LegPool(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegPool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegPool *arg1 = (FIX::LegPool *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegPool",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegPool, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegPool" "', argument " "1"" of type '" "FIX::LegPool *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegPool * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegPool_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegPool, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ShortQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ShortQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ShortQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ShortQty *)new FIX::ShortQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ShortQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShortQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ShortQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ShortQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShortQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShortQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ShortQty *)new FIX::ShortQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ShortQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShortQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ShortQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ShortQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShortQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ShortQty::ShortQty()\n"
    "    FIX::ShortQty::ShortQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ShortQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ShortQty *arg1 = (FIX::ShortQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ShortQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ShortQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShortQty" "', argument " "1"" of type '" "FIX::ShortQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ShortQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ShortQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ShortQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SideValue2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideValue2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideValue2")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideValue2 *)new FIX::SideValue2();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideValue2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideValue2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideValue2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideValue2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideValue2" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideValue2" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideValue2 *)new FIX::SideValue2((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideValue2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideValue2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideValue2__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideValue2__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideValue2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideValue2::SideValue2()\n"
    "    FIX::SideValue2::SideValue2(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideValue2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideValue2 *arg1 = (FIX::SideValue2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideValue2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideValue2, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideValue2" "', argument " "1"" of type '" "FIX::SideValue2 *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideValue2 * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SideValue2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SideValue2, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradedFlatSwitch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradedFlatSwitch *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradedFlatSwitch")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradedFlatSwitch *)new FIX::TradedFlatSwitch();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradedFlatSwitch, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradedFlatSwitch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradedFlatSwitch *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradedFlatSwitch",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradedFlatSwitch" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradedFlatSwitch" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradedFlatSwitch *)new FIX::TradedFlatSwitch((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradedFlatSwitch, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradedFlatSwitch(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradedFlatSwitch__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradedFlatSwitch__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradedFlatSwitch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradedFlatSwitch::TradedFlatSwitch()\n"
    "    FIX::TradedFlatSwitch::TradedFlatSwitch(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradedFlatSwitch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradedFlatSwitch *arg1 = (FIX::TradedFlatSwitch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradedFlatSwitch",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradedFlatSwitch, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradedFlatSwitch" "', argument " "1"" of type '" "FIX::TradedFlatSwitch *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradedFlatSwitch * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradedFlatSwitch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradedFlatSwitch, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MassStatusReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassStatusReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MassStatusReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassStatusReqID *)new FIX::MassStatusReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassStatusReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassStatusReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MassStatusReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MassStatusReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MassStatusReqID *)new FIX::MassStatusReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MassStatusReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MassStatusReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MassStatusReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MassStatusReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MassStatusReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MassStatusReqID::MassStatusReqID()\n"
    "    FIX::MassStatusReqID::MassStatusReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MassStatusReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MassStatusReqID *arg1 = (FIX::MassStatusReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MassStatusReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MassStatusReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MassStatusReqID" "', argument " "1"" of type '" "FIX::MassStatusReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MassStatusReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MassStatusReqID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MassStatusReqID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ComplexEventEndDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventEndDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ComplexEventEndDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventEndDate *)new FIX::ComplexEventEndDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventEndDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventEndDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ComplexEventEndDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ComplexEventEndDate",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ComplexEventEndDate" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventEndDate *)new FIX::ComplexEventEndDate(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventEndDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventEndDate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ComplexEventEndDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ComplexEventEndDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexEventEndDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplexEventEndDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventEndDate *)new FIX::ComplexEventEndDate((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventEndDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventEndDate__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::ComplexEventEndDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ComplexEventEndDate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexEventEndDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplexEventEndDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ComplexEventEndDate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventEndDate *)new FIX::ComplexEventEndDate((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventEndDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventEndDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ComplexEventEndDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventEndDate__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_ComplexEventEndDate__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ComplexEventEndDate__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ComplexEventEndDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ComplexEventEndDate::ComplexEventEndDate()\n"
    "    FIX::ComplexEventEndDate::ComplexEventEndDate(bool)\n"
    "    FIX::ComplexEventEndDate::ComplexEventEndDate(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::ComplexEventEndDate::ComplexEventEndDate(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ComplexEventEndDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventEndDate *arg1 = (FIX::ComplexEventEndDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ComplexEventEndDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ComplexEventEndDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComplexEventEndDate" "', argument " "1"" of type '" "FIX::ComplexEventEndDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ComplexEventEndDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ComplexEventEndDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ComplexEventEndDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MarketID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarketID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MarketID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarketID *)new FIX::MarketID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarketID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MarketID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MarketID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarketID" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarketID" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarketID *)new FIX::MarketID((FIX::EXCHANGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarketID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MarketID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarketID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarketID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MarketID::MarketID()\n"
    "    FIX::MarketID::MarketID(FIX::EXCHANGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MarketID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarketID *arg1 = (FIX::MarketID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MarketID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MarketID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarketID" "', argument " "1"" of type '" "FIX::MarketID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MarketID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MarketID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MarketID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OrigTradeDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigTradeDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrigTradeDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigTradeDate *)new FIX::OrigTradeDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigTradeDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTradeDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrigTradeDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrigTradeDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrigTradeDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrigTradeDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigTradeDate *)new FIX::OrigTradeDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigTradeDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTradeDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrigTradeDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigTradeDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrigTradeDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrigTradeDate::OrigTradeDate()\n"
    "    FIX::OrigTradeDate::OrigTradeDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrigTradeDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigTradeDate *arg1 = (FIX::OrigTradeDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrigTradeDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrigTradeDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrigTradeDate" "', argument " "1"" of type '" "FIX::OrigTradeDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrigTradeDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrigTradeDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrigTradeDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PreTradeAnonymity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PreTradeAnonymity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PreTradeAnonymity")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PreTradeAnonymity *)new FIX::PreTradeAnonymity();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PreTradeAnonymity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PreTradeAnonymity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PreTradeAnonymity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PreTradeAnonymity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PreTradeAnonymity" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PreTradeAnonymity" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PreTradeAnonymity *)new FIX::PreTradeAnonymity((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PreTradeAnonymity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PreTradeAnonymity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PreTradeAnonymity__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PreTradeAnonymity__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PreTradeAnonymity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PreTradeAnonymity::PreTradeAnonymity()\n"
    "    FIX::PreTradeAnonymity::PreTradeAnonymity(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PreTradeAnonymity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PreTradeAnonymity *arg1 = (FIX::PreTradeAnonymity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PreTradeAnonymity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PreTradeAnonymity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PreTradeAnonymity" "', argument " "1"" of type '" "FIX::PreTradeAnonymity *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PreTradeAnonymity * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PreTradeAnonymity_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PreTradeAnonymity, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TrdRptStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdRptStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TrdRptStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdRptStatus *)new FIX::TrdRptStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdRptStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRptStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TrdRptStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TrdRptStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrdRptStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TrdRptStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdRptStatus *)new FIX::TrdRptStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdRptStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRptStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TrdRptStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdRptStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TrdRptStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TrdRptStatus::TrdRptStatus()\n"
    "    FIX::TrdRptStatus::TrdRptStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TrdRptStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdRptStatus *arg1 = (FIX::TrdRptStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TrdRptStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TrdRptStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrdRptStatus" "', argument " "1"" of type '" "FIX::TrdRptStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TrdRptStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TrdRptStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TrdRptStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DistribPercentage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DistribPercentage *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DistribPercentage")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DistribPercentage *)new FIX::DistribPercentage();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DistribPercentage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DistribPercentage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DistribPercentage *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DistribPercentage",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DistribPercentage" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DistribPercentage" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DistribPercentage *)new FIX::DistribPercentage((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DistribPercentage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DistribPercentage(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DistribPercentage__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DistribPercentage__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DistribPercentage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DistribPercentage::DistribPercentage()\n"
    "    FIX::DistribPercentage::DistribPercentage(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DistribPercentage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DistribPercentage *arg1 = (FIX::DistribPercentage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DistribPercentage",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DistribPercentage, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DistribPercentage" "', argument " "1"" of type '" "FIX::DistribPercentage *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DistribPercentage * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DistribPercentage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DistribPercentage, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_QuoteStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteStatus *)new FIX::QuoteStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteStatus *)new FIX::QuoteStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteStatus::QuoteStatus()\n"
    "    FIX::QuoteStatus::QuoteStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteStatus *arg1 = (FIX::QuoteStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteStatus" "', argument " "1"" of type '" "FIX::QuoteStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__QuoteStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ClearingAccount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClearingAccount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ClearingAccount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClearingAccount *)new FIX::ClearingAccount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClearingAccount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingAccount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ClearingAccount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ClearingAccount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClearingAccount" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ClearingAccount" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClearingAccount *)new FIX::ClearingAccount((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClearingAccount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClearingAccount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ClearingAccount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClearingAccount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ClearingAccount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ClearingAccount::ClearingAccount()\n"
    "    FIX::ClearingAccount::ClearingAccount(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ClearingAccount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClearingAccount *arg1 = (FIX::ClearingAccount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ClearingAccount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ClearingAccount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClearingAccount" "', argument " "1"" of type '" "FIX::ClearingAccount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ClearingAccount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ClearingAccount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ClearingAccount, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TrdMatchID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdMatchID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TrdMatchID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdMatchID *)new FIX::TrdMatchID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdMatchID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdMatchID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TrdMatchID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TrdMatchID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrdMatchID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TrdMatchID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdMatchID *)new FIX::TrdMatchID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdMatchID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdMatchID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TrdMatchID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdMatchID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TrdMatchID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TrdMatchID::TrdMatchID()\n"
    "    FIX::TrdMatchID::TrdMatchID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TrdMatchID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdMatchID *arg1 = (FIX::TrdMatchID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TrdMatchID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TrdMatchID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrdMatchID" "', argument " "1"" of type '" "FIX::TrdMatchID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TrdMatchID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TrdMatchID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TrdMatchID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OrderInputDevice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderInputDevice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrderInputDevice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderInputDevice *)new FIX::OrderInputDevice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderInputDevice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderInputDevice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrderInputDevice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrderInputDevice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrderInputDevice" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrderInputDevice" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderInputDevice *)new FIX::OrderInputDevice((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderInputDevice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderInputDevice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrderInputDevice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderInputDevice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrderInputDevice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrderInputDevice::OrderInputDevice()\n"
    "    FIX::OrderInputDevice::OrderInputDevice(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrderInputDevice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderInputDevice *arg1 = (FIX::OrderInputDevice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrderInputDevice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrderInputDevice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrderInputDevice" "', argument " "1"" of type '" "FIX::OrderInputDevice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrderInputDevice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrderInputDevice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrderInputDevice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SolicitedFlag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SolicitedFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SolicitedFlag")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SolicitedFlag *)new FIX::SolicitedFlag();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SolicitedFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SolicitedFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SolicitedFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SolicitedFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SolicitedFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SolicitedFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SolicitedFlag *)new FIX::SolicitedFlag((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SolicitedFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SolicitedFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SolicitedFlag__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SolicitedFlag__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SolicitedFlag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SolicitedFlag::SolicitedFlag()\n"
    "    FIX::SolicitedFlag::SolicitedFlag(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SolicitedFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SolicitedFlag *arg1 = (FIX::SolicitedFlag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SolicitedFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SolicitedFlag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SolicitedFlag" "', argument " "1"" of type '" "FIX::SolicitedFlag *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SolicitedFlag * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SolicitedFlag_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SolicitedFlag, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TransactTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TransactTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TransactTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TransactTime *)new FIX::TransactTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TransactTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransactTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TransactTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TransactTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TransactTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TransactTime *)new FIX::TransactTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TransactTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransactTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TransactTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TransactTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TransactTime *)new FIX::TransactTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TransactTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransactTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::TransactTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TransactTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TransactTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TransactTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TransactTime *)new FIX::TransactTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TransactTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransactTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TransactTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TransactTime__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_TransactTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TransactTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TransactTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TransactTime::TransactTime()\n"
    "    FIX::TransactTime::TransactTime(bool)\n"
    "    FIX::TransactTime::TransactTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::TransactTime::TransactTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TransactTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TransactTime *arg1 = (FIX::TransactTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TransactTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TransactTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransactTime" "', argument " "1"" of type '" "FIX::TransactTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TransactTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TransactTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TransactTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingFlowScheduleType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingFlowScheduleType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingFlowScheduleType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingFlowScheduleType *)new FIX::UnderlyingFlowScheduleType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingFlowScheduleType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFlowScheduleType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingFlowScheduleType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingFlowScheduleType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingFlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingFlowScheduleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingFlowScheduleType *)new FIX::UnderlyingFlowScheduleType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingFlowScheduleType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFlowScheduleType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingFlowScheduleType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingFlowScheduleType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingFlowScheduleType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingFlowScheduleType::UnderlyingFlowScheduleType()\n"
    "    FIX::UnderlyingFlowScheduleType::UnderlyingFlowScheduleType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingFlowScheduleType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingFlowScheduleType *arg1 = (FIX::UnderlyingFlowScheduleType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingFlowScheduleType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingFlowScheduleType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingFlowScheduleType" "', argument " "1"" of type '" "FIX::UnderlyingFlowScheduleType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingFlowScheduleType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingFlowScheduleType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingFlowScheduleType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingStipValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingStipValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingStipValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingStipValue *)new FIX::UnderlyingStipValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingStipValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStipValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingStipValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingStipValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingStipValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingStipValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingStipValue *)new FIX::UnderlyingStipValue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingStipValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStipValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingStipValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingStipValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingStipValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingStipValue::UnderlyingStipValue()\n"
    "    FIX::UnderlyingStipValue::UnderlyingStipValue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingStipValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingStipValue *arg1 = (FIX::UnderlyingStipValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingStipValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingStipValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingStipValue" "', argument " "1"" of type '" "FIX::UnderlyingStipValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingStipValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingStipValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingStipValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NextExpectedMsgSeqNum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NextExpectedMsgSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NextExpectedMsgSeqNum")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NextExpectedMsgSeqNum *)new FIX::NextExpectedMsgSeqNum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NextExpectedMsgSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NextExpectedMsgSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NextExpectedMsgSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NextExpectedMsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SEQNUM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NextExpectedMsgSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NextExpectedMsgSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NextExpectedMsgSeqNum *)new FIX::NextExpectedMsgSeqNum((FIX::SEQNUM const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NextExpectedMsgSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NextExpectedMsgSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NextExpectedMsgSeqNum__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NextExpectedMsgSeqNum__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NextExpectedMsgSeqNum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NextExpectedMsgSeqNum::NextExpectedMsgSeqNum()\n"
    "    FIX::NextExpectedMsgSeqNum::NextExpectedMsgSeqNum(FIX::SEQNUM const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NextExpectedMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NextExpectedMsgSeqNum *arg1 = (FIX::NextExpectedMsgSeqNum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NextExpectedMsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NextExpectedMsgSeqNum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NextExpectedMsgSeqNum" "', argument " "1"" of type '" "FIX::NextExpectedMsgSeqNum *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NextExpectedMsgSeqNum * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NextExpectedMsgSeqNum_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NextExpectedMsgSeqNum, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BenchmarkCurveCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BenchmarkCurveCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BenchmarkCurveCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BenchmarkCurveCurrency *)new FIX::BenchmarkCurveCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BenchmarkCurveCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkCurveCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BenchmarkCurveCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BenchmarkCurveCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BenchmarkCurveCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BenchmarkCurveCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BenchmarkCurveCurrency *)new FIX::BenchmarkCurveCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BenchmarkCurveCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkCurveCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BenchmarkCurveCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BenchmarkCurveCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BenchmarkCurveCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BenchmarkCurveCurrency::BenchmarkCurveCurrency()\n"
    "    FIX::BenchmarkCurveCurrency::BenchmarkCurveCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BenchmarkCurveCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BenchmarkCurveCurrency *arg1 = (FIX::BenchmarkCurveCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BenchmarkCurveCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BenchmarkCurveCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BenchmarkCurveCurrency" "', argument " "1"" of type '" "FIX::BenchmarkCurveCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BenchmarkCurveCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BenchmarkCurveCurrency_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BenchmarkCurveCurrency, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CFICode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CFICode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CFICode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CFICode *)new FIX::CFICode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CFICode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CFICode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CFICode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CFICode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CFICode *)new FIX::CFICode((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CFICode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CFICode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CFICode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CFICode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CFICode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CFICode::CFICode()\n"
    "    FIX::CFICode::CFICode(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CFICode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CFICode *arg1 = (FIX::CFICode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CFICode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CFICode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CFICode" "', argument " "1"" of type '" "FIX::CFICode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CFICode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CFICode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CFICode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Factor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Factor *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Factor")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Factor *)new FIX::Factor();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Factor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Factor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Factor *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Factor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Factor" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Factor" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Factor *)new FIX::Factor((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Factor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Factor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Factor__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Factor__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Factor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Factor::Factor()\n"
    "    FIX::Factor::Factor(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Factor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Factor *arg1 = (FIX::Factor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Factor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Factor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Factor" "', argument " "1"" of type '" "FIX::Factor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Factor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Factor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Factor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LastShares__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastShares *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastShares")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastShares *)new FIX::LastShares();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastShares, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastShares__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastShares *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastShares",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastShares" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastShares" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastShares *)new FIX::LastShares((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastShares, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastShares(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastShares__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastShares__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastShares'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastShares::LastShares()\n"
    "    FIX::LastShares::LastShares(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastShares(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastShares *arg1 = (FIX::LastShares *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastShares",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastShares, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastShares" "', argument " "1"" of type '" "FIX::LastShares *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastShares * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LastShares_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LastShares, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EventTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EventTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EventTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EventTime *)new FIX::EventTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EventTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EventTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EventTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EventTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EventTime *)new FIX::EventTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EventTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EventTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EventTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EventTime *)new FIX::EventTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EventTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::EventTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_EventTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EventTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EventTime *)new FIX::EventTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EventTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EventTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EventTime__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_EventTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_EventTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EventTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EventTime::EventTime()\n"
    "    FIX::EventTime::EventTime(bool)\n"
    "    FIX::EventTime::EventTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::EventTime::EventTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EventTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EventTime *arg1 = (FIX::EventTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EventTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EventTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventTime" "', argument " "1"" of type '" "FIX::EventTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EventTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EventTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EventTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RootPartySubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RootPartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RootPartySubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RootPartySubIDType *)new FIX::RootPartySubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RootPartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RootPartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RootPartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RootPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RootPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RootPartySubIDType *)new FIX::RootPartySubIDType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RootPartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RootPartySubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RootPartySubIDType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RootPartySubIDType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RootPartySubIDType::RootPartySubIDType()\n"
    "    FIX::RootPartySubIDType::RootPartySubIDType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RootPartySubIDType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RootPartySubIDType *arg1 = (FIX::RootPartySubIDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RootPartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RootPartySubIDType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RootPartySubIDType" "', argument " "1"" of type '" "FIX::RootPartySubIDType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RootPartySubIDType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RootPartySubIDType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RootPartySubIDType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ShortSaleReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ShortSaleReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ShortSaleReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ShortSaleReason *)new FIX::ShortSaleReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ShortSaleReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShortSaleReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ShortSaleReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ShortSaleReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShortSaleReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShortSaleReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ShortSaleReason *)new FIX::ShortSaleReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ShortSaleReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ShortSaleReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ShortSaleReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ShortSaleReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ShortSaleReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ShortSaleReason::ShortSaleReason()\n"
    "    FIX::ShortSaleReason::ShortSaleReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ShortSaleReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ShortSaleReason *arg1 = (FIX::ShortSaleReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ShortSaleReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ShortSaleReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShortSaleReason" "', argument " "1"" of type '" "FIX::ShortSaleReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ShortSaleReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ShortSaleReason_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ShortSaleReason, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_XmlData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::XmlData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_XmlData")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::XmlData *)new FIX::XmlData();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__XmlData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XmlData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::XmlData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_XmlData",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XmlData" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XmlData" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::XmlData *)new FIX::XmlData((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__XmlData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XmlData(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_XmlData__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XmlData__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_XmlData'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::XmlData::XmlData()\n"
    "    FIX::XmlData::XmlData(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_XmlData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::XmlData *arg1 = (FIX::XmlData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_XmlData",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__XmlData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XmlData" "', argument " "1"" of type '" "FIX::XmlData *""'"); 
  }
  arg1 = reinterpret_cast< FIX::XmlData * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *XmlData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__XmlData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoTargetPartyIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTargetPartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoTargetPartyIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTargetPartyIDs *)new FIX::NoTargetPartyIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTargetPartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTargetPartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoTargetPartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoTargetPartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoTargetPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoTargetPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTargetPartyIDs *)new FIX::NoTargetPartyIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTargetPartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTargetPartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoTargetPartyIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTargetPartyIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoTargetPartyIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoTargetPartyIDs::NoTargetPartyIDs()\n"
    "    FIX::NoTargetPartyIDs::NoTargetPartyIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoTargetPartyIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTargetPartyIDs *arg1 = (FIX::NoTargetPartyIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoTargetPartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoTargetPartyIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoTargetPartyIDs" "', argument " "1"" of type '" "FIX::NoTargetPartyIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoTargetPartyIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoTargetPartyIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoTargetPartyIDs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoRootPartyIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRootPartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoRootPartyIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRootPartyIDs *)new FIX::NoRootPartyIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRootPartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRootPartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoRootPartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRootPartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoRootPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRootPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRootPartyIDs *)new FIX::NoRootPartyIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRootPartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRootPartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoRootPartyIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoRootPartyIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoRootPartyIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoRootPartyIDs::NoRootPartyIDs()\n"
    "    FIX::NoRootPartyIDs::NoRootPartyIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoRootPartyIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRootPartyIDs *arg1 = (FIX::NoRootPartyIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoRootPartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoRootPartyIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoRootPartyIDs" "', argument " "1"" of type '" "FIX::NoRootPartyIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoRootPartyIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoRootPartyIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRootPartyIDs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EventDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EventDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EventDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EventDate *)new FIX::EventDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EventDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EventDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EventDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EventDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EventDate *)new FIX::EventDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EventDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EventDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EventDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EventDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EventDate::EventDate()\n"
    "    FIX::EventDate::EventDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EventDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EventDate *arg1 = (FIX::EventDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EventDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EventDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventDate" "', argument " "1"" of type '" "FIX::EventDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EventDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EventDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EventDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PegRoundDirection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegRoundDirection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PegRoundDirection")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegRoundDirection *)new FIX::PegRoundDirection();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegRoundDirection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegRoundDirection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PegRoundDirection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PegRoundDirection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PegRoundDirection" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PegRoundDirection" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegRoundDirection *)new FIX::PegRoundDirection((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegRoundDirection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegRoundDirection(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PegRoundDirection__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegRoundDirection__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PegRoundDirection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PegRoundDirection::PegRoundDirection()\n"
    "    FIX::PegRoundDirection::PegRoundDirection(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PegRoundDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegRoundDirection *arg1 = (FIX::PegRoundDirection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PegRoundDirection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PegRoundDirection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PegRoundDirection" "', argument " "1"" of type '" "FIX::PegRoundDirection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PegRoundDirection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PegRoundDirection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PegRoundDirection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegSettlDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSettlDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSettlDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSettlDate *)new FIX::LegSettlDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSettlDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSettlDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSettlDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSettlDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSettlDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSettlDate *)new FIX::LegSettlDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSettlDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSettlDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSettlDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSettlDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSettlDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSettlDate::LegSettlDate()\n"
    "    FIX::LegSettlDate::LegSettlDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSettlDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSettlDate *arg1 = (FIX::LegSettlDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSettlDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSettlDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSettlDate" "', argument " "1"" of type '" "FIX::LegSettlDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSettlDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegSettlDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegSettlDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ModelType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ModelType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ModelType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ModelType *)new FIX::ModelType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ModelType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModelType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ModelType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ModelType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ModelType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ModelType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ModelType *)new FIX::ModelType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ModelType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ModelType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ModelType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ModelType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ModelType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ModelType::ModelType()\n"
    "    FIX::ModelType::ModelType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ModelType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ModelType *arg1 = (FIX::ModelType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ModelType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ModelType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModelType" "', argument " "1"" of type '" "FIX::ModelType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ModelType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ModelType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ModelType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DefaultVerIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DefaultVerIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DefaultVerIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DefaultVerIndicator *)new FIX::DefaultVerIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DefaultVerIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultVerIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DefaultVerIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DefaultVerIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DefaultVerIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultVerIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DefaultVerIndicator *)new FIX::DefaultVerIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DefaultVerIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultVerIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DefaultVerIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefaultVerIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DefaultVerIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DefaultVerIndicator::DefaultVerIndicator()\n"
    "    FIX::DefaultVerIndicator::DefaultVerIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DefaultVerIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DefaultVerIndicator *arg1 = (FIX::DefaultVerIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DefaultVerIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DefaultVerIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultVerIndicator" "', argument " "1"" of type '" "FIX::DefaultVerIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DefaultVerIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefaultVerIndicator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DefaultVerIndicator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FuturesValuationMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FuturesValuationMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FuturesValuationMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FuturesValuationMethod *)new FIX::FuturesValuationMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FuturesValuationMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesValuationMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FuturesValuationMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FuturesValuationMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FuturesValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FuturesValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FuturesValuationMethod *)new FIX::FuturesValuationMethod((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FuturesValuationMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FuturesValuationMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FuturesValuationMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FuturesValuationMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FuturesValuationMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FuturesValuationMethod::FuturesValuationMethod()\n"
    "    FIX::FuturesValuationMethod::FuturesValuationMethod(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FuturesValuationMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FuturesValuationMethod *arg1 = (FIX::FuturesValuationMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FuturesValuationMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FuturesValuationMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FuturesValuationMethod" "', argument " "1"" of type '" "FIX::FuturesValuationMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FuturesValuationMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FuturesValuationMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FuturesValuationMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlMethod *)new FIX::SettlMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlMethod *)new FIX::SettlMethod((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlMethod::SettlMethod()\n"
    "    FIX::SettlMethod::SettlMethod(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlMethod *arg1 = (FIX::SettlMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlMethod" "', argument " "1"" of type '" "FIX::SettlMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingFXRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingFXRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingFXRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingFXRate *)new FIX::UnderlyingFXRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingFXRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFXRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingFXRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingFXRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingFXRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingFXRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingFXRate *)new FIX::UnderlyingFXRate((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingFXRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFXRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingFXRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingFXRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingFXRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingFXRate::UnderlyingFXRate()\n"
    "    FIX::UnderlyingFXRate::UnderlyingFXRate(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingFXRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingFXRate *arg1 = (FIX::UnderlyingFXRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingFXRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingFXRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingFXRate" "', argument " "1"" of type '" "FIX::UnderlyingFXRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingFXRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingFXRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingFXRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ConfirmStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfirmStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ConfirmStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfirmStatus *)new FIX::ConfirmStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfirmStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ConfirmStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ConfirmStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfirmStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConfirmStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfirmStatus *)new FIX::ConfirmStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfirmStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ConfirmStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfirmStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ConfirmStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ConfirmStatus::ConfirmStatus()\n"
    "    FIX::ConfirmStatus::ConfirmStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConfirmStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfirmStatus *arg1 = (FIX::ConfirmStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ConfirmStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ConfirmStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfirmStatus" "', argument " "1"" of type '" "FIX::ConfirmStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ConfirmStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConfirmStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ConfirmStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LocateReqd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LocateReqd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LocateReqd")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LocateReqd *)new FIX::LocateReqd();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocateReqd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocateReqd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LocateReqd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LocateReqd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocateReqd" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocateReqd" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LocateReqd *)new FIX::LocateReqd((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocateReqd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocateReqd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LocateReqd__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocateReqd__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LocateReqd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LocateReqd::LocateReqd()\n"
    "    FIX::LocateReqd::LocateReqd(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LocateReqd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LocateReqd *arg1 = (FIX::LocateReqd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LocateReqd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LocateReqd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocateReqd" "', argument " "1"" of type '" "FIX::LocateReqd *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LocateReqd * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LocateReqd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LocateReqd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PosMaintRptID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosMaintRptID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PosMaintRptID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosMaintRptID *)new FIX::PosMaintRptID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosMaintRptID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintRptID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PosMaintRptID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PosMaintRptID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PosMaintRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PosMaintRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosMaintRptID *)new FIX::PosMaintRptID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosMaintRptID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintRptID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PosMaintRptID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosMaintRptID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PosMaintRptID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PosMaintRptID::PosMaintRptID()\n"
    "    FIX::PosMaintRptID::PosMaintRptID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PosMaintRptID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosMaintRptID *arg1 = (FIX::PosMaintRptID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PosMaintRptID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PosMaintRptID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PosMaintRptID" "', argument " "1"" of type '" "FIX::PosMaintRptID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PosMaintRptID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PosMaintRptID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PosMaintRptID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Adjustment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Adjustment *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Adjustment")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Adjustment *)new FIX::Adjustment();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Adjustment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Adjustment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Adjustment *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Adjustment",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Adjustment" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Adjustment" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Adjustment *)new FIX::Adjustment((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Adjustment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Adjustment(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Adjustment__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Adjustment__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Adjustment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Adjustment::Adjustment()\n"
    "    FIX::Adjustment::Adjustment(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Adjustment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Adjustment *arg1 = (FIX::Adjustment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Adjustment",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Adjustment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Adjustment" "', argument " "1"" of type '" "FIX::Adjustment *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Adjustment * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Adjustment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Adjustment, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StreamAsgnType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StreamAsgnType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StreamAsgnType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StreamAsgnType *)new FIX::StreamAsgnType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StreamAsgnType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StreamAsgnType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StreamAsgnType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StreamAsgnType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StreamAsgnType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StreamAsgnType *)new FIX::StreamAsgnType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StreamAsgnType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StreamAsgnType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StreamAsgnType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StreamAsgnType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StreamAsgnType::StreamAsgnType()\n"
    "    FIX::StreamAsgnType::StreamAsgnType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StreamAsgnType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StreamAsgnType *arg1 = (FIX::StreamAsgnType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StreamAsgnType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StreamAsgnType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StreamAsgnType" "', argument " "1"" of type '" "FIX::StreamAsgnType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StreamAsgnType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StreamAsgnType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__StreamAsgnType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LastRptRequested__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastRptRequested *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastRptRequested")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastRptRequested *)new FIX::LastRptRequested();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastRptRequested, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastRptRequested__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastRptRequested *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastRptRequested",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastRptRequested" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastRptRequested" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastRptRequested *)new FIX::LastRptRequested((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastRptRequested, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastRptRequested(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastRptRequested__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastRptRequested__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastRptRequested'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastRptRequested::LastRptRequested()\n"
    "    FIX::LastRptRequested::LastRptRequested(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastRptRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastRptRequested *arg1 = (FIX::LastRptRequested *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastRptRequested",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastRptRequested, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastRptRequested" "', argument " "1"" of type '" "FIX::LastRptRequested *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastRptRequested * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LastRptRequested_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LastRptRequested, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LocaleOfIssue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LocaleOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LocaleOfIssue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LocaleOfIssue *)new FIX::LocaleOfIssue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocaleOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocaleOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LocaleOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LocaleOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LocaleOfIssue *)new FIX::LocaleOfIssue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LocaleOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LocaleOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LocaleOfIssue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LocaleOfIssue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LocaleOfIssue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LocaleOfIssue::LocaleOfIssue()\n"
    "    FIX::LocaleOfIssue::LocaleOfIssue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LocaleOfIssue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LocaleOfIssue *arg1 = (FIX::LocaleOfIssue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LocaleOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LocaleOfIssue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocaleOfIssue" "', argument " "1"" of type '" "FIX::LocaleOfIssue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LocaleOfIssue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LocaleOfIssue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LocaleOfIssue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SenderSubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SenderSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SenderSubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SenderSubID *)new FIX::SenderSubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SenderSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SenderSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SenderSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SenderSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SenderSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SenderSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SenderSubID *)new FIX::SenderSubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SenderSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SenderSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SenderSubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SenderSubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SenderSubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SenderSubID::SenderSubID()\n"
    "    FIX::SenderSubID::SenderSubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SenderSubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SenderSubID *arg1 = (FIX::SenderSubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SenderSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SenderSubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SenderSubID" "', argument " "1"" of type '" "FIX::SenderSubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SenderSubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SenderSubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SenderSubID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HighPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HighPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HighPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HighPx *)new FIX::HighPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HighPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HighPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::HighPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HighPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HighPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HighPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HighPx *)new FIX::HighPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HighPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HighPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_HighPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HighPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HighPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::HighPx::HighPx()\n"
    "    FIX::HighPx::HighPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HighPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HighPx *arg1 = (FIX::HighPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HighPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__HighPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HighPx" "', argument " "1"" of type '" "FIX::HighPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::HighPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HighPx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__HighPx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocSettlCurrAmt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocSettlCurrAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocSettlCurrAmt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocSettlCurrAmt *)new FIX::AllocSettlCurrAmt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocSettlCurrAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocSettlCurrAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocSettlCurrAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocSettlCurrAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocSettlCurrAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocSettlCurrAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocSettlCurrAmt *)new FIX::AllocSettlCurrAmt((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocSettlCurrAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocSettlCurrAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocSettlCurrAmt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocSettlCurrAmt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocSettlCurrAmt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocSettlCurrAmt::AllocSettlCurrAmt()\n"
    "    FIX::AllocSettlCurrAmt::AllocSettlCurrAmt(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocSettlCurrAmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocSettlCurrAmt *arg1 = (FIX::AllocSettlCurrAmt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocSettlCurrAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocSettlCurrAmt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocSettlCurrAmt" "', argument " "1"" of type '" "FIX::AllocSettlCurrAmt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocSettlCurrAmt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocSettlCurrAmt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocSettlCurrAmt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ComplexEventPriceBoundaryPrecision__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventPriceBoundaryPrecision *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ComplexEventPriceBoundaryPrecision")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventPriceBoundaryPrecision *)new FIX::ComplexEventPriceBoundaryPrecision();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventPriceBoundaryPrecision, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPriceBoundaryPrecision__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ComplexEventPriceBoundaryPrecision *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ComplexEventPriceBoundaryPrecision",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexEventPriceBoundaryPrecision" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplexEventPriceBoundaryPrecision" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventPriceBoundaryPrecision *)new FIX::ComplexEventPriceBoundaryPrecision((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventPriceBoundaryPrecision, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPriceBoundaryPrecision(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ComplexEventPriceBoundaryPrecision__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventPriceBoundaryPrecision__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ComplexEventPriceBoundaryPrecision'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ComplexEventPriceBoundaryPrecision::ComplexEventPriceBoundaryPrecision()\n"
    "    FIX::ComplexEventPriceBoundaryPrecision::ComplexEventPriceBoundaryPrecision(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ComplexEventPriceBoundaryPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventPriceBoundaryPrecision *arg1 = (FIX::ComplexEventPriceBoundaryPrecision *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ComplexEventPriceBoundaryPrecision",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ComplexEventPriceBoundaryPrecision, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComplexEventPriceBoundaryPrecision" "', argument " "1"" of type '" "FIX::ComplexEventPriceBoundaryPrecision *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ComplexEventPriceBoundaryPrecision * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ComplexEventPriceBoundaryPrecision_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ComplexEventPriceBoundaryPrecision, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_InstrumentPartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrumentPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InstrumentPartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrumentPartyRole *)new FIX::InstrumentPartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrumentPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InstrumentPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InstrumentPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrumentPartyRole *)new FIX::InstrumentPartyRole((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrumentPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InstrumentPartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrumentPartyRole__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InstrumentPartyRole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InstrumentPartyRole::InstrumentPartyRole()\n"
    "    FIX::InstrumentPartyRole::InstrumentPartyRole(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InstrumentPartyRole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrumentPartyRole *arg1 = (FIX::InstrumentPartyRole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InstrumentPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InstrumentPartyRole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InstrumentPartyRole" "', argument " "1"" of type '" "FIX::InstrumentPartyRole *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InstrumentPartyRole * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InstrumentPartyRole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__InstrumentPartyRole, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_YieldRedemptionPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::YieldRedemptionPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_YieldRedemptionPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::YieldRedemptionPrice *)new FIX::YieldRedemptionPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__YieldRedemptionPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldRedemptionPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::YieldRedemptionPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_YieldRedemptionPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YieldRedemptionPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YieldRedemptionPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::YieldRedemptionPrice *)new FIX::YieldRedemptionPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__YieldRedemptionPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldRedemptionPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_YieldRedemptionPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YieldRedemptionPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_YieldRedemptionPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::YieldRedemptionPrice::YieldRedemptionPrice()\n"
    "    FIX::YieldRedemptionPrice::YieldRedemptionPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YieldRedemptionPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::YieldRedemptionPrice *arg1 = (FIX::YieldRedemptionPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_YieldRedemptionPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__YieldRedemptionPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YieldRedemptionPrice" "', argument " "1"" of type '" "FIX::YieldRedemptionPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::YieldRedemptionPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YieldRedemptionPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__YieldRedemptionPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CumQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CumQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CumQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CumQty *)new FIX::CumQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CumQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CumQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CumQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CumQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CumQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CumQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CumQty *)new FIX::CumQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CumQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CumQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CumQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CumQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CumQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CumQty::CumQty()\n"
    "    FIX::CumQty::CumQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CumQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CumQty *arg1 = (FIX::CumQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CumQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CumQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CumQty" "', argument " "1"" of type '" "FIX::CumQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CumQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CumQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CumQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OrigClOrdID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigClOrdID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrigClOrdID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigClOrdID *)new FIX::OrigClOrdID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigClOrdID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigClOrdID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrigClOrdID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrigClOrdID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrigClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrigClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigClOrdID *)new FIX::OrigClOrdID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigClOrdID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigClOrdID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrigClOrdID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigClOrdID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrigClOrdID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrigClOrdID::OrigClOrdID()\n"
    "    FIX::OrigClOrdID::OrigClOrdID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrigClOrdID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigClOrdID *arg1 = (FIX::OrigClOrdID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrigClOrdID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrigClOrdID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrigClOrdID" "', argument " "1"" of type '" "FIX::OrigClOrdID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrigClOrdID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrigClOrdID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrigClOrdID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlSessID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlSessID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlSessID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlSessID *)new FIX::SettlSessID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlSessID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlSessID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlSessID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlSessID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlSessID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlSessID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlSessID *)new FIX::SettlSessID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlSessID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlSessID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlSessID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlSessID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlSessID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlSessID::SettlSessID()\n"
    "    FIX::SettlSessID::SettlSessID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlSessID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlSessID *arg1 = (FIX::SettlSessID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlSessID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlSessID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlSessID" "', argument " "1"" of type '" "FIX::SettlSessID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlSessID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlSessID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlSessID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ParentMktSegmID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ParentMktSegmID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ParentMktSegmID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ParentMktSegmID *)new FIX::ParentMktSegmID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ParentMktSegmID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParentMktSegmID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ParentMktSegmID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ParentMktSegmID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParentMktSegmID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParentMktSegmID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ParentMktSegmID *)new FIX::ParentMktSegmID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ParentMktSegmID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParentMktSegmID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ParentMktSegmID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ParentMktSegmID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ParentMktSegmID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ParentMktSegmID::ParentMktSegmID()\n"
    "    FIX::ParentMktSegmID::ParentMktSegmID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ParentMktSegmID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ParentMktSegmID *arg1 = (FIX::ParentMktSegmID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ParentMktSegmID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ParentMktSegmID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ParentMktSegmID" "', argument " "1"" of type '" "FIX::ParentMktSegmID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ParentMktSegmID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ParentMktSegmID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ParentMktSegmID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradeReportType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeReportType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeReportType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeReportType *)new FIX::TradeReportType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeReportType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeReportType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeReportType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeReportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeReportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeReportType *)new FIX::TradeReportType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeReportType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeReportType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeReportType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeReportType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeReportType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeReportType::TradeReportType()\n"
    "    FIX::TradeReportType::TradeReportType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeReportType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeReportType *arg1 = (FIX::TradeReportType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeReportType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeReportType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeReportType" "', argument " "1"" of type '" "FIX::TradeReportType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeReportType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradeReportType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradeReportType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AvgPrxPrecision__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AvgPrxPrecision *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AvgPrxPrecision")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AvgPrxPrecision *)new FIX::AvgPrxPrecision();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AvgPrxPrecision, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPrxPrecision__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AvgPrxPrecision *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AvgPrxPrecision",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AvgPrxPrecision" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AvgPrxPrecision" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AvgPrxPrecision *)new FIX::AvgPrxPrecision((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AvgPrxPrecision, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPrxPrecision(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AvgPrxPrecision__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AvgPrxPrecision__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AvgPrxPrecision'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AvgPrxPrecision::AvgPrxPrecision()\n"
    "    FIX::AvgPrxPrecision::AvgPrxPrecision(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AvgPrxPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AvgPrxPrecision *arg1 = (FIX::AvgPrxPrecision *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AvgPrxPrecision",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AvgPrxPrecision, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AvgPrxPrecision" "', argument " "1"" of type '" "FIX::AvgPrxPrecision *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AvgPrxPrecision * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AvgPrxPrecision_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AvgPrxPrecision, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoLegs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoLegs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoLegs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoLegs *)new FIX::NoLegs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoLegs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLegs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoLegs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoLegs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoLegs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoLegs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoLegs *)new FIX::NoLegs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoLegs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLegs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoLegs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoLegs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoLegs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoLegs::NoLegs()\n"
    "    FIX::NoLegs::NoLegs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoLegs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoLegs *arg1 = (FIX::NoLegs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoLegs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoLegs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoLegs" "', argument " "1"" of type '" "FIX::NoLegs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoLegs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoLegs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoLegs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingSymbol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSymbol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSymbol")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSymbol *)new FIX::UnderlyingSymbol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSymbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSymbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSymbol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSymbol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSymbol *)new FIX::UnderlyingSymbol((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSymbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSymbol__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSymbol__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSymbol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSymbol::UnderlyingSymbol()\n"
    "    FIX::UnderlyingSymbol::UnderlyingSymbol(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSymbol *arg1 = (FIX::UnderlyingSymbol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSymbol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSymbol, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSymbol" "', argument " "1"" of type '" "FIX::UnderlyingSymbol *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingSymbol_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingSymbol, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExerciseStyle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExerciseStyle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExerciseStyle")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExerciseStyle *)new FIX::ExerciseStyle();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExerciseStyle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExerciseStyle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExerciseStyle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExerciseStyle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExerciseStyle *)new FIX::ExerciseStyle((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExerciseStyle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExerciseStyle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExerciseStyle__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExerciseStyle__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExerciseStyle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExerciseStyle::ExerciseStyle()\n"
    "    FIX::ExerciseStyle::ExerciseStyle(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExerciseStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExerciseStyle *arg1 = (FIX::ExerciseStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExerciseStyle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExerciseStyle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExerciseStyle" "', argument " "1"" of type '" "FIX::ExerciseStyle *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExerciseStyle * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExerciseStyle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ExerciseStyle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HaltReasonChar__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HaltReasonChar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HaltReasonChar")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HaltReasonChar *)new FIX::HaltReasonChar();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HaltReasonChar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaltReasonChar__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::HaltReasonChar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HaltReasonChar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HaltReasonChar" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HaltReasonChar" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HaltReasonChar *)new FIX::HaltReasonChar((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HaltReasonChar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HaltReasonChar(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_HaltReasonChar__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HaltReasonChar__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HaltReasonChar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::HaltReasonChar::HaltReasonChar()\n"
    "    FIX::HaltReasonChar::HaltReasonChar(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HaltReasonChar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HaltReasonChar *arg1 = (FIX::HaltReasonChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HaltReasonChar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__HaltReasonChar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HaltReasonChar" "', argument " "1"" of type '" "FIX::HaltReasonChar *""'"); 
  }
  arg1 = reinterpret_cast< FIX::HaltReasonChar * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HaltReasonChar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__HaltReasonChar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExDestination__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExDestination *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExDestination")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExDestination *)new FIX::ExDestination();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExDestination, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExDestination__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExDestination *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExDestination",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExDestination" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExDestination" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExDestination *)new FIX::ExDestination((FIX::EXCHANGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExDestination, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExDestination(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExDestination__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExDestination__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExDestination'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExDestination::ExDestination()\n"
    "    FIX::ExDestination::ExDestination(FIX::EXCHANGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExDestination(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExDestination *arg1 = (FIX::ExDestination *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExDestination",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExDestination, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExDestination" "', argument " "1"" of type '" "FIX::ExDestination *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExDestination * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExDestination_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ExDestination, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeInstrmtAssignmentMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrmtAssignmentMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeInstrmtAssignmentMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrmtAssignmentMethod *)new FIX::DerivativeInstrmtAssignmentMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrmtAssignmentMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrmtAssignmentMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeInstrmtAssignmentMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeInstrmtAssignmentMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeInstrmtAssignmentMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeInstrmtAssignmentMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrmtAssignmentMethod *)new FIX::DerivativeInstrmtAssignmentMethod((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrmtAssignmentMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrmtAssignmentMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeInstrmtAssignmentMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrmtAssignmentMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeInstrmtAssignmentMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeInstrmtAssignmentMethod::DerivativeInstrmtAssignmentMethod()\n"
    "    FIX::DerivativeInstrmtAssignmentMethod::DerivativeInstrmtAssignmentMethod(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeInstrmtAssignmentMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrmtAssignmentMethod *arg1 = (FIX::DerivativeInstrmtAssignmentMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeInstrmtAssignmentMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeInstrmtAssignmentMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeInstrmtAssignmentMethod" "', argument " "1"" of type '" "FIX::DerivativeInstrmtAssignmentMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeInstrmtAssignmentMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeInstrmtAssignmentMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeInstrmtAssignmentMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingIDSource *)new FIX::UnderlyingIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingIDSource *)new FIX::UnderlyingIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingIDSource::UnderlyingIDSource()\n"
    "    FIX::UnderlyingIDSource::UnderlyingIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingIDSource *arg1 = (FIX::UnderlyingIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingIDSource" "', argument " "1"" of type '" "FIX::UnderlyingIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AdvId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AdvId *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AdvId")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AdvId *)new FIX::AdvId();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AdvId, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AdvId *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AdvId",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AdvId" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AdvId" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AdvId *)new FIX::AdvId((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AdvId, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvId(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AdvId__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AdvId__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AdvId'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AdvId::AdvId()\n"
    "    FIX::AdvId::AdvId(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AdvId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AdvId *arg1 = (FIX::AdvId *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AdvId",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AdvId, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AdvId" "', argument " "1"" of type '" "FIX::AdvId *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AdvId * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AdvId_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AdvId, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TransBkdTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TransBkdTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TransBkdTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TransBkdTime *)new FIX::TransBkdTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TransBkdTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransBkdTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TransBkdTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TransBkdTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TransBkdTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TransBkdTime *)new FIX::TransBkdTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TransBkdTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransBkdTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TransBkdTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TransBkdTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransBkdTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TransBkdTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TransBkdTime *)new FIX::TransBkdTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TransBkdTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransBkdTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::TransBkdTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TransBkdTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransBkdTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TransBkdTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TransBkdTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TransBkdTime *)new FIX::TransBkdTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TransBkdTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransBkdTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TransBkdTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TransBkdTime__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_TransBkdTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TransBkdTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TransBkdTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TransBkdTime::TransBkdTime()\n"
    "    FIX::TransBkdTime::TransBkdTime(bool)\n"
    "    FIX::TransBkdTime::TransBkdTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::TransBkdTime::TransBkdTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TransBkdTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TransBkdTime *arg1 = (FIX::TransBkdTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TransBkdTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TransBkdTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransBkdTime" "', argument " "1"" of type '" "FIX::TransBkdTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TransBkdTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TransBkdTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TransBkdTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegLastPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegLastPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegLastPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegLastPx *)new FIX::LegLastPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegLastPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLastPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegLastPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegLastPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegLastPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegLastPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegLastPx *)new FIX::LegLastPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegLastPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLastPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegLastPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegLastPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegLastPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegLastPx::LegLastPx()\n"
    "    FIX::LegLastPx::LegLastPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegLastPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegLastPx *arg1 = (FIX::LegLastPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegLastPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegLastPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegLastPx" "', argument " "1"" of type '" "FIX::LegLastPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegLastPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegLastPx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegLastPx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocReportType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocReportType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocReportType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocReportType *)new FIX::AllocReportType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocReportType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocReportType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocReportType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocReportType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocReportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocReportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocReportType *)new FIX::AllocReportType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocReportType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocReportType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocReportType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocReportType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocReportType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocReportType::AllocReportType()\n"
    "    FIX::AllocReportType::AllocReportType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocReportType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocReportType *arg1 = (FIX::AllocReportType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocReportType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocReportType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocReportType" "', argument " "1"" of type '" "FIX::AllocReportType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocReportType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocReportType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocReportType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RegistDtls__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistDtls *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RegistDtls")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistDtls *)new FIX::RegistDtls();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistDtls, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistDtls__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RegistDtls *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RegistDtls",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegistDtls" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegistDtls" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistDtls *)new FIX::RegistDtls((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistDtls, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistDtls(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RegistDtls__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistDtls__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RegistDtls'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RegistDtls::RegistDtls()\n"
    "    FIX::RegistDtls::RegistDtls(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RegistDtls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistDtls *arg1 = (FIX::RegistDtls *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RegistDtls",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RegistDtls, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegistDtls" "', argument " "1"" of type '" "FIX::RegistDtls *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RegistDtls * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RegistDtls_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RegistDtls, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocType *)new FIX::AllocType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocType *)new FIX::AllocType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocType::AllocType()\n"
    "    FIX::AllocType::AllocType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocType *arg1 = (FIX::AllocType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocType" "', argument " "1"" of type '" "FIX::AllocType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_QuoteRequestRejectReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteRequestRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteRequestRejectReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteRequestRejectReason *)new FIX::QuoteRequestRejectReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteRequestRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRequestRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteRequestRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteRequestRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteRequestRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteRequestRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteRequestRejectReason *)new FIX::QuoteRequestRejectReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteRequestRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRequestRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteRequestRejectReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteRequestRejectReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteRequestRejectReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteRequestRejectReason::QuoteRequestRejectReason()\n"
    "    FIX::QuoteRequestRejectReason::QuoteRequestRejectReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteRequestRejectReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteRequestRejectReason *arg1 = (FIX::QuoteRequestRejectReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteRequestRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteRequestRejectReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteRequestRejectReason" "', argument " "1"" of type '" "FIX::QuoteRequestRejectReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteRequestRejectReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteRequestRejectReason_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__QuoteRequestRejectReason, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingUnitOfMeasure__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingUnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingUnitOfMeasure")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingUnitOfMeasure *)new FIX::UnderlyingUnitOfMeasure();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingUnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingUnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingUnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingUnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingUnitOfMeasure *)new FIX::UnderlyingUnitOfMeasure((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingUnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingUnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingUnitOfMeasure__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingUnitOfMeasure__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingUnitOfMeasure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingUnitOfMeasure::UnderlyingUnitOfMeasure()\n"
    "    FIX::UnderlyingUnitOfMeasure::UnderlyingUnitOfMeasure(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingUnitOfMeasure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingUnitOfMeasure *arg1 = (FIX::UnderlyingUnitOfMeasure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingUnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingUnitOfMeasure, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingUnitOfMeasure" "', argument " "1"" of type '" "FIX::UnderlyingUnitOfMeasure *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingUnitOfMeasure * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingUnitOfMeasure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingUnitOfMeasure, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_IndividualAllocID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IndividualAllocID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IndividualAllocID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IndividualAllocID *)new FIX::IndividualAllocID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IndividualAllocID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndividualAllocID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IndividualAllocID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IndividualAllocID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IndividualAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IndividualAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IndividualAllocID *)new FIX::IndividualAllocID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IndividualAllocID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndividualAllocID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IndividualAllocID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IndividualAllocID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IndividualAllocID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IndividualAllocID::IndividualAllocID()\n"
    "    FIX::IndividualAllocID::IndividualAllocID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IndividualAllocID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IndividualAllocID *arg1 = (FIX::IndividualAllocID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IndividualAllocID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IndividualAllocID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IndividualAllocID" "', argument " "1"" of type '" "FIX::IndividualAllocID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IndividualAllocID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IndividualAllocID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__IndividualAllocID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegOfferPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegOfferPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegOfferPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegOfferPx *)new FIX::LegOfferPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegOfferPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOfferPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegOfferPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegOfferPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegOfferPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegOfferPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegOfferPx *)new FIX::LegOfferPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegOfferPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOfferPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegOfferPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegOfferPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegOfferPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegOfferPx::LegOfferPx()\n"
    "    FIX::LegOfferPx::LegOfferPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegOfferPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegOfferPx *arg1 = (FIX::LegOfferPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegOfferPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegOfferPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegOfferPx" "', argument " "1"" of type '" "FIX::LegOfferPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegOfferPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegOfferPx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegOfferPx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LiquidityIndType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LiquidityIndType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LiquidityIndType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LiquidityIndType *)new FIX::LiquidityIndType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LiquidityIndType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityIndType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LiquidityIndType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LiquidityIndType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LiquidityIndType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LiquidityIndType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LiquidityIndType *)new FIX::LiquidityIndType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LiquidityIndType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityIndType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LiquidityIndType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LiquidityIndType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LiquidityIndType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LiquidityIndType::LiquidityIndType()\n"
    "    FIX::LiquidityIndType::LiquidityIndType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LiquidityIndType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LiquidityIndType *arg1 = (FIX::LiquidityIndType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LiquidityIndType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LiquidityIndType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LiquidityIndType" "', argument " "1"" of type '" "FIX::LiquidityIndType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LiquidityIndType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LiquidityIndType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LiquidityIndType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HopSendingTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HopSendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HopSendingTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HopSendingTime *)new FIX::HopSendingTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HopSendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopSendingTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::HopSendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HopSendingTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HopSendingTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HopSendingTime *)new FIX::HopSendingTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HopSendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopSendingTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::HopSendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HopSendingTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HopSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HopSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HopSendingTime *)new FIX::HopSendingTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HopSendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopSendingTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::HopSendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_HopSendingTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HopSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HopSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HopSendingTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HopSendingTime *)new FIX::HopSendingTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HopSendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopSendingTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_HopSendingTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HopSendingTime__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_HopSendingTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_HopSendingTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HopSendingTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::HopSendingTime::HopSendingTime()\n"
    "    FIX::HopSendingTime::HopSendingTime(bool)\n"
    "    FIX::HopSendingTime::HopSendingTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::HopSendingTime::HopSendingTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HopSendingTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HopSendingTime *arg1 = (FIX::HopSendingTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HopSendingTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__HopSendingTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HopSendingTime" "', argument " "1"" of type '" "FIX::HopSendingTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::HopSendingTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HopSendingTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__HopSendingTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ApplResendFlag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplResendFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplResendFlag")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplResendFlag *)new FIX::ApplResendFlag();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplResendFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResendFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplResendFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplResendFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplResendFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplResendFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplResendFlag *)new FIX::ApplResendFlag((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplResendFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResendFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplResendFlag__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplResendFlag__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplResendFlag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplResendFlag::ApplResendFlag()\n"
    "    FIX::ApplResendFlag::ApplResendFlag(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplResendFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplResendFlag *arg1 = (FIX::ApplResendFlag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplResendFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplResendFlag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplResendFlag" "', argument " "1"" of type '" "FIX::ApplResendFlag *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplResendFlag * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ApplResendFlag_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ApplResendFlag, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeCapPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeCapPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeCapPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeCapPrice *)new FIX::DerivativeCapPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeCapPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeCapPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeCapPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeCapPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeCapPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeCapPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeCapPrice *)new FIX::DerivativeCapPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeCapPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeCapPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeCapPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeCapPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeCapPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeCapPrice::DerivativeCapPrice()\n"
    "    FIX::DerivativeCapPrice::DerivativeCapPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeCapPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeCapPrice *arg1 = (FIX::DerivativeCapPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeCapPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeCapPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeCapPrice" "', argument " "1"" of type '" "FIX::DerivativeCapPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeCapPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeCapPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeCapPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ComplexOptPayoutAmount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexOptPayoutAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ComplexOptPayoutAmount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexOptPayoutAmount *)new FIX::ComplexOptPayoutAmount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexOptPayoutAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexOptPayoutAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ComplexOptPayoutAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ComplexOptPayoutAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexOptPayoutAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplexOptPayoutAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexOptPayoutAmount *)new FIX::ComplexOptPayoutAmount((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexOptPayoutAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexOptPayoutAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ComplexOptPayoutAmount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexOptPayoutAmount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ComplexOptPayoutAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ComplexOptPayoutAmount::ComplexOptPayoutAmount()\n"
    "    FIX::ComplexOptPayoutAmount::ComplexOptPayoutAmount(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ComplexOptPayoutAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexOptPayoutAmount *arg1 = (FIX::ComplexOptPayoutAmount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ComplexOptPayoutAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ComplexOptPayoutAmount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComplexOptPayoutAmount" "', argument " "1"" of type '" "FIX::ComplexOptPayoutAmount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ComplexOptPayoutAmount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ComplexOptPayoutAmount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ComplexOptPayoutAmount, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LanguageCode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LanguageCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LanguageCode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LanguageCode *)new FIX::LanguageCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LanguageCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LanguageCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LANGUAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LanguageCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LanguageCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LANGUAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LanguageCode" "', argument " "1"" of type '" "FIX::LANGUAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LanguageCode" "', argument " "1"" of type '" "FIX::LANGUAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LANGUAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LanguageCode *)new FIX::LanguageCode((FIX::LANGUAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LanguageCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LanguageCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LanguageCode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LANGUAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LanguageCode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LanguageCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LanguageCode::LanguageCode()\n"
    "    FIX::LanguageCode::LanguageCode(FIX::LANGUAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LanguageCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LanguageCode *arg1 = (FIX::LanguageCode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LanguageCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LanguageCode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LanguageCode" "', argument " "1"" of type '" "FIX::LanguageCode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LanguageCode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LanguageCode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LanguageCode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlObligRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlObligRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlObligRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlObligRefID *)new FIX::SettlObligRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlObligRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlObligRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlObligRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlObligRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlObligRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlObligRefID *)new FIX::SettlObligRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlObligRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlObligRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlObligRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlObligRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlObligRefID::SettlObligRefID()\n"
    "    FIX::SettlObligRefID::SettlObligRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlObligRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlObligRefID *arg1 = (FIX::SettlObligRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlObligRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlObligRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlObligRefID" "', argument " "1"" of type '" "FIX::SettlObligRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlObligRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlObligRefID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlObligRefID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OrigTradeID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigTradeID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrigTradeID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigTradeID *)new FIX::OrigTradeID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigTradeID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTradeID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrigTradeID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrigTradeID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrigTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrigTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigTradeID *)new FIX::OrigTradeID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigTradeID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigTradeID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrigTradeID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigTradeID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrigTradeID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrigTradeID::OrigTradeID()\n"
    "    FIX::OrigTradeID::OrigTradeID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrigTradeID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigTradeID *arg1 = (FIX::OrigTradeID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrigTradeID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrigTradeID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrigTradeID" "', argument " "1"" of type '" "FIX::OrigTradeID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrigTradeID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrigTradeID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrigTradeID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingCollectAmount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCollectAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingCollectAmount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCollectAmount *)new FIX::UnderlyingCollectAmount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCollectAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCollectAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingCollectAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingCollectAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingCollectAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingCollectAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCollectAmount *)new FIX::UnderlyingCollectAmount((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCollectAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCollectAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingCollectAmount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCollectAmount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingCollectAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingCollectAmount::UnderlyingCollectAmount()\n"
    "    FIX::UnderlyingCollectAmount::UnderlyingCollectAmount(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingCollectAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCollectAmount *arg1 = (FIX::UnderlyingCollectAmount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingCollectAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingCollectAmount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingCollectAmount" "', argument " "1"" of type '" "FIX::UnderlyingCollectAmount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingCollectAmount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingCollectAmount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingCollectAmount, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StatusValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StatusValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StatusValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StatusValue *)new FIX::StatusValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StatusValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StatusValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StatusValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StatusValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StatusValue" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StatusValue" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StatusValue *)new FIX::StatusValue((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StatusValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StatusValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StatusValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StatusValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StatusValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StatusValue::StatusValue()\n"
    "    FIX::StatusValue::StatusValue(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StatusValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StatusValue *arg1 = (FIX::StatusValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StatusValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StatusValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StatusValue" "', argument " "1"" of type '" "FIX::StatusValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StatusValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StatusValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__StatusValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OfferSpotRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OfferSpotRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OfferSpotRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OfferSpotRate *)new FIX::OfferSpotRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OfferSpotRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferSpotRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OfferSpotRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OfferSpotRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OfferSpotRate" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OfferSpotRate" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OfferSpotRate *)new FIX::OfferSpotRate((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OfferSpotRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OfferSpotRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OfferSpotRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OfferSpotRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OfferSpotRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OfferSpotRate::OfferSpotRate()\n"
    "    FIX::OfferSpotRate::OfferSpotRate(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OfferSpotRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OfferSpotRate *arg1 = (FIX::OfferSpotRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OfferSpotRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OfferSpotRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OfferSpotRate" "', argument " "1"" of type '" "FIX::OfferSpotRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OfferSpotRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OfferSpotRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OfferSpotRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PosType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PosType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosType *)new FIX::PosType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PosType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PosType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PosType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PosType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosType *)new FIX::PosType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PosType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PosType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PosType::PosType()\n"
    "    FIX::PosType::PosType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PosType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosType *arg1 = (FIX::PosType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PosType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PosType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PosType" "', argument " "1"" of type '" "FIX::PosType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PosType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PosType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PosType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingRedemptionDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingRedemptionDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingRedemptionDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingRedemptionDate *)new FIX::UnderlyingRedemptionDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingRedemptionDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRedemptionDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingRedemptionDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingRedemptionDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingRedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingRedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingRedemptionDate *)new FIX::UnderlyingRedemptionDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingRedemptionDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRedemptionDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingRedemptionDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingRedemptionDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingRedemptionDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingRedemptionDate::UnderlyingRedemptionDate()\n"
    "    FIX::UnderlyingRedemptionDate::UnderlyingRedemptionDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingRedemptionDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingRedemptionDate *arg1 = (FIX::UnderlyingRedemptionDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingRedemptionDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingRedemptionDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingRedemptionDate" "', argument " "1"" of type '" "FIX::UnderlyingRedemptionDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingRedemptionDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingRedemptionDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingRedemptionDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlDepositoryCode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlDepositoryCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlDepositoryCode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlDepositoryCode *)new FIX::SettlDepositoryCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlDepositoryCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDepositoryCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlDepositoryCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlDepositoryCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlDepositoryCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlDepositoryCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlDepositoryCode *)new FIX::SettlDepositoryCode((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlDepositoryCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDepositoryCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlDepositoryCode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlDepositoryCode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlDepositoryCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlDepositoryCode::SettlDepositoryCode()\n"
    "    FIX::SettlDepositoryCode::SettlDepositoryCode(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlDepositoryCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlDepositoryCode *arg1 = (FIX::SettlDepositoryCode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlDepositoryCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlDepositoryCode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlDepositoryCode" "', argument " "1"" of type '" "FIX::SettlDepositoryCode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlDepositoryCode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlDepositoryCode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlDepositoryCode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StreamAsgnAckType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StreamAsgnAckType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StreamAsgnAckType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StreamAsgnAckType *)new FIX::StreamAsgnAckType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StreamAsgnAckType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnAckType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StreamAsgnAckType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StreamAsgnAckType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StreamAsgnAckType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StreamAsgnAckType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StreamAsgnAckType *)new FIX::StreamAsgnAckType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StreamAsgnAckType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StreamAsgnAckType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StreamAsgnAckType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StreamAsgnAckType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StreamAsgnAckType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StreamAsgnAckType::StreamAsgnAckType()\n"
    "    FIX::StreamAsgnAckType::StreamAsgnAckType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StreamAsgnAckType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StreamAsgnAckType *arg1 = (FIX::StreamAsgnAckType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StreamAsgnAckType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StreamAsgnAckType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StreamAsgnAckType" "', argument " "1"" of type '" "FIX::StreamAsgnAckType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StreamAsgnAckType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StreamAsgnAckType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__StreamAsgnAckType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FloorPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FloorPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FloorPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FloorPrice *)new FIX::FloorPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FloorPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloorPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FloorPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FloorPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloorPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloorPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FloorPrice *)new FIX::FloorPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FloorPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FloorPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FloorPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FloorPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FloorPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FloorPrice::FloorPrice()\n"
    "    FIX::FloorPrice::FloorPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FloorPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FloorPrice *arg1 = (FIX::FloorPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FloorPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FloorPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloorPrice" "', argument " "1"" of type '" "FIX::FloorPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FloorPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FloorPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FloorPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingPriceUnitOfMeasureQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingPriceUnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingPriceUnitOfMeasureQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingPriceUnitOfMeasureQty *)new FIX::UnderlyingPriceUnitOfMeasureQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPriceUnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingPriceUnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingPriceUnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingPriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingPriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingPriceUnitOfMeasureQty *)new FIX::UnderlyingPriceUnitOfMeasureQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPriceUnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingPriceUnitOfMeasureQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingPriceUnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingPriceUnitOfMeasureQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingPriceUnitOfMeasureQty::UnderlyingPriceUnitOfMeasureQty()\n"
    "    FIX::UnderlyingPriceUnitOfMeasureQty::UnderlyingPriceUnitOfMeasureQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingPriceUnitOfMeasureQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingPriceUnitOfMeasureQty *arg1 = (FIX::UnderlyingPriceUnitOfMeasureQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingPriceUnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasureQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingPriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::UnderlyingPriceUnitOfMeasureQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingPriceUnitOfMeasureQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingPriceUnitOfMeasureQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasureQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FeeMultiplier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FeeMultiplier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FeeMultiplier")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FeeMultiplier *)new FIX::FeeMultiplier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FeeMultiplier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FeeMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FeeMultiplier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FeeMultiplier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FeeMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FeeMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FeeMultiplier *)new FIX::FeeMultiplier((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FeeMultiplier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FeeMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FeeMultiplier__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FeeMultiplier__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FeeMultiplier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FeeMultiplier::FeeMultiplier()\n"
    "    FIX::FeeMultiplier::FeeMultiplier(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FeeMultiplier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FeeMultiplier *arg1 = (FIX::FeeMultiplier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FeeMultiplier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FeeMultiplier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FeeMultiplier" "', argument " "1"" of type '" "FIX::FeeMultiplier *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FeeMultiplier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FeeMultiplier_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FeeMultiplier, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingMaturityTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingMaturityTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingMaturityTime *)new FIX::UnderlyingMaturityTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingMaturityTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTIMEONLY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingMaturityTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingMaturityTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__TZTIMEONLY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingMaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMEONLY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingMaturityTime *)new FIX::UnderlyingMaturityTime((FIX::TZTIMEONLY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingMaturityTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingMaturityTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__TZTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingMaturityTime__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingMaturityTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingMaturityTime::UnderlyingMaturityTime()\n"
    "    FIX::UnderlyingMaturityTime::UnderlyingMaturityTime(FIX::TZTIMEONLY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingMaturityTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingMaturityTime *arg1 = (FIX::UnderlyingMaturityTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingMaturityTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingMaturityTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingMaturityTime" "', argument " "1"" of type '" "FIX::UnderlyingMaturityTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingMaturityTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingMaturityTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingMaturityTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ApplID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplID *)new FIX::ApplID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplID *)new FIX::ApplID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplID::ApplID()\n"
    "    FIX::ApplID::ApplID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplID *arg1 = (FIX::ApplID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplID" "', argument " "1"" of type '" "FIX::ApplID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ApplID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ApplID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegGrossTradeAmt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegGrossTradeAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegGrossTradeAmt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegGrossTradeAmt *)new FIX::LegGrossTradeAmt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegGrossTradeAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegGrossTradeAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegGrossTradeAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegGrossTradeAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegGrossTradeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegGrossTradeAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegGrossTradeAmt *)new FIX::LegGrossTradeAmt((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegGrossTradeAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegGrossTradeAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegGrossTradeAmt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegGrossTradeAmt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegGrossTradeAmt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegGrossTradeAmt::LegGrossTradeAmt()\n"
    "    FIX::LegGrossTradeAmt::LegGrossTradeAmt(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegGrossTradeAmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegGrossTradeAmt *arg1 = (FIX::LegGrossTradeAmt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegGrossTradeAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegGrossTradeAmt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegGrossTradeAmt" "', argument " "1"" of type '" "FIX::LegGrossTradeAmt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegGrossTradeAmt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegGrossTradeAmt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegGrossTradeAmt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MDEntryDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDEntryDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryDate *)new FIX::MDEntryDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCDATEONLY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDEntryDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDEntryDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCDATEONLY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDEntryDate" "', argument " "1"" of type '" "FIX::UTCDATEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDEntryDate" "', argument " "1"" of type '" "FIX::UTCDATEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCDATEONLY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryDate *)new FIX::MDEntryDate((FIX::UTCDATEONLY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDEntryDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCDATEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDEntryDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDEntryDate::MDEntryDate()\n"
    "    FIX::MDEntryDate::MDEntryDate(FIX::UTCDATEONLY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDEntryDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryDate *arg1 = (FIX::MDEntryDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDEntryDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDEntryDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDEntryDate" "', argument " "1"" of type '" "FIX::MDEntryDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDEntryDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MDEntryDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MDEntryDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurveCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegBenchmarkCurveCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegBenchmarkCurveCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegBenchmarkCurveCurrency *)new FIX::LegBenchmarkCurveCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegBenchmarkCurveCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurveCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegBenchmarkCurveCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegBenchmarkCurveCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegBenchmarkCurveCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegBenchmarkCurveCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegBenchmarkCurveCurrency *)new FIX::LegBenchmarkCurveCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegBenchmarkCurveCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBenchmarkCurveCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegBenchmarkCurveCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegBenchmarkCurveCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegBenchmarkCurveCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegBenchmarkCurveCurrency::LegBenchmarkCurveCurrency()\n"
    "    FIX::LegBenchmarkCurveCurrency::LegBenchmarkCurveCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegBenchmarkCurveCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegBenchmarkCurveCurrency *arg1 = (FIX::LegBenchmarkCurveCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegBenchmarkCurveCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegBenchmarkCurveCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegBenchmarkCurveCurrency" "', argument " "1"" of type '" "FIX::LegBenchmarkCurveCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegBenchmarkCurveCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegBenchmarkCurveCurrency_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegBenchmarkCurveCurrency, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OptPayoutAmount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OptPayoutAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OptPayoutAmount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OptPayoutAmount *)new FIX::OptPayoutAmount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OptPayoutAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptPayoutAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OptPayoutAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OptPayoutAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OptPayoutAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OptPayoutAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OptPayoutAmount *)new FIX::OptPayoutAmount((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OptPayoutAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptPayoutAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OptPayoutAmount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OptPayoutAmount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OptPayoutAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OptPayoutAmount::OptPayoutAmount()\n"
    "    FIX::OptPayoutAmount::OptPayoutAmount(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OptPayoutAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OptPayoutAmount *arg1 = (FIX::OptPayoutAmount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OptPayoutAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OptPayoutAmount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptPayoutAmount" "', argument " "1"" of type '" "FIX::OptPayoutAmount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OptPayoutAmount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OptPayoutAmount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OptPayoutAmount, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MiscFeeBasis__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MiscFeeBasis *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MiscFeeBasis")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MiscFeeBasis *)new FIX::MiscFeeBasis();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MiscFeeBasis, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeBasis__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MiscFeeBasis *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MiscFeeBasis",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MiscFeeBasis" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MiscFeeBasis" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MiscFeeBasis *)new FIX::MiscFeeBasis((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MiscFeeBasis, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MiscFeeBasis(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MiscFeeBasis__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MiscFeeBasis__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MiscFeeBasis'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MiscFeeBasis::MiscFeeBasis()\n"
    "    FIX::MiscFeeBasis::MiscFeeBasis(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MiscFeeBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MiscFeeBasis *arg1 = (FIX::MiscFeeBasis *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MiscFeeBasis",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MiscFeeBasis, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MiscFeeBasis" "', argument " "1"" of type '" "FIX::MiscFeeBasis *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MiscFeeBasis * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MiscFeeBasis_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MiscFeeBasis, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ValidUntilTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ValidUntilTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ValidUntilTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ValidUntilTime *)new FIX::ValidUntilTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ValidUntilTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValidUntilTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ValidUntilTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ValidUntilTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ValidUntilTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ValidUntilTime *)new FIX::ValidUntilTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ValidUntilTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValidUntilTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ValidUntilTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ValidUntilTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ValidUntilTime *)new FIX::ValidUntilTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ValidUntilTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValidUntilTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::ValidUntilTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ValidUntilTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ValidUntilTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ValidUntilTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ValidUntilTime *)new FIX::ValidUntilTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ValidUntilTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ValidUntilTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ValidUntilTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ValidUntilTime__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_ValidUntilTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ValidUntilTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ValidUntilTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ValidUntilTime::ValidUntilTime()\n"
    "    FIX::ValidUntilTime::ValidUntilTime(bool)\n"
    "    FIX::ValidUntilTime::ValidUntilTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::ValidUntilTime::ValidUntilTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ValidUntilTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ValidUntilTime *arg1 = (FIX::ValidUntilTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ValidUntilTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ValidUntilTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ValidUntilTime" "', argument " "1"" of type '" "FIX::ValidUntilTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ValidUntilTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ValidUntilTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ValidUntilTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OrdType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrdType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrdType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrdType *)new FIX::OrdType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrdType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrdType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrdType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrdType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrdType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrdType *)new FIX::OrdType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrdType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrdType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrdType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrdType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrdType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrdType::OrdType()\n"
    "    FIX::OrdType::OrdType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrdType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrdType *arg1 = (FIX::OrdType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrdType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrdType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrdType" "', argument " "1"" of type '" "FIX::OrdType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrdType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrdType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrdType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AdvRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AdvRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AdvRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AdvRefID *)new FIX::AdvRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AdvRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AdvRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AdvRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AdvRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AdvRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AdvRefID *)new FIX::AdvRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AdvRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AdvRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AdvRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AdvRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AdvRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AdvRefID::AdvRefID()\n"
    "    FIX::AdvRefID::AdvRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AdvRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AdvRefID *arg1 = (FIX::AdvRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AdvRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AdvRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AdvRefID" "', argument " "1"" of type '" "FIX::AdvRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AdvRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AdvRefID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AdvRefID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HopCompID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HopCompID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HopCompID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HopCompID *)new FIX::HopCompID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HopCompID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopCompID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::HopCompID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HopCompID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HopCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HopCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::HopCompID *)new FIX::HopCompID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__HopCompID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HopCompID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_HopCompID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HopCompID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HopCompID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::HopCompID::HopCompID()\n"
    "    FIX::HopCompID::HopCompID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HopCompID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::HopCompID *arg1 = (FIX::HopCompID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HopCompID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__HopCompID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HopCompID" "', argument " "1"" of type '" "FIX::HopCompID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::HopCompID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HopCompID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__HopCompID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PosMaintRptRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosMaintRptRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PosMaintRptRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosMaintRptRefID *)new FIX::PosMaintRptRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosMaintRptRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintRptRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PosMaintRptRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PosMaintRptRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PosMaintRptRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PosMaintRptRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosMaintRptRefID *)new FIX::PosMaintRptRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosMaintRptRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintRptRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PosMaintRptRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosMaintRptRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PosMaintRptRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PosMaintRptRefID::PosMaintRptRefID()\n"
    "    FIX::PosMaintRptRefID::PosMaintRptRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PosMaintRptRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosMaintRptRefID *arg1 = (FIX::PosMaintRptRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PosMaintRptRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PosMaintRptRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PosMaintRptRefID" "', argument " "1"" of type '" "FIX::PosMaintRptRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PosMaintRptRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PosMaintRptRefID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PosMaintRptRefID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegStipulationValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegStipulationValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegStipulationValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegStipulationValue *)new FIX::LegStipulationValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegStipulationValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStipulationValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegStipulationValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegStipulationValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegStipulationValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegStipulationValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegStipulationValue *)new FIX::LegStipulationValue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegStipulationValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStipulationValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegStipulationValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegStipulationValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegStipulationValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegStipulationValue::LegStipulationValue()\n"
    "    FIX::LegStipulationValue::LegStipulationValue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegStipulationValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegStipulationValue *arg1 = (FIX::LegStipulationValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegStipulationValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegStipulationValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegStipulationValue" "', argument " "1"" of type '" "FIX::LegStipulationValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegStipulationValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegStipulationValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegStipulationValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MatchType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MatchType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MatchType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MatchType *)new FIX::MatchType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MatchType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MatchType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MatchType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatchType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatchType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MatchType *)new FIX::MatchType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MatchType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MatchType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MatchType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MatchType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MatchType::MatchType()\n"
    "    FIX::MatchType::MatchType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MatchType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MatchType *arg1 = (FIX::MatchType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MatchType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MatchType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MatchType" "', argument " "1"" of type '" "FIX::MatchType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MatchType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MatchType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MatchType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OptPayoutType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OptPayoutType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OptPayoutType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OptPayoutType *)new FIX::OptPayoutType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OptPayoutType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptPayoutType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OptPayoutType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OptPayoutType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OptPayoutType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OptPayoutType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OptPayoutType *)new FIX::OptPayoutType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OptPayoutType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptPayoutType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OptPayoutType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OptPayoutType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OptPayoutType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OptPayoutType::OptPayoutType()\n"
    "    FIX::OptPayoutType::OptPayoutType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OptPayoutType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OptPayoutType *arg1 = (FIX::OptPayoutType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OptPayoutType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OptPayoutType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptPayoutType" "', argument " "1"" of type '" "FIX::OptPayoutType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OptPayoutType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OptPayoutType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OptPayoutType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingPriceUnitOfMeasure__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingPriceUnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingPriceUnitOfMeasure")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingPriceUnitOfMeasure *)new FIX::UnderlyingPriceUnitOfMeasure();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPriceUnitOfMeasure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingPriceUnitOfMeasure *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingPriceUnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingPriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingPriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingPriceUnitOfMeasure *)new FIX::UnderlyingPriceUnitOfMeasure((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasure, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPriceUnitOfMeasure(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingPriceUnitOfMeasure__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingPriceUnitOfMeasure__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingPriceUnitOfMeasure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingPriceUnitOfMeasure::UnderlyingPriceUnitOfMeasure()\n"
    "    FIX::UnderlyingPriceUnitOfMeasure::UnderlyingPriceUnitOfMeasure(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingPriceUnitOfMeasure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingPriceUnitOfMeasure *arg1 = (FIX::UnderlyingPriceUnitOfMeasure *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingPriceUnitOfMeasure",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasure, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingPriceUnitOfMeasure" "', argument " "1"" of type '" "FIX::UnderlyingPriceUnitOfMeasure *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingPriceUnitOfMeasure * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingPriceUnitOfMeasure_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingPriceUnitOfMeasure, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MarketUpdateAction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarketUpdateAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MarketUpdateAction")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarketUpdateAction *)new FIX::MarketUpdateAction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarketUpdateAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketUpdateAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MarketUpdateAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MarketUpdateAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarketUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarketUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarketUpdateAction *)new FIX::MarketUpdateAction((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarketUpdateAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarketUpdateAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MarketUpdateAction__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarketUpdateAction__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarketUpdateAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MarketUpdateAction::MarketUpdateAction()\n"
    "    FIX::MarketUpdateAction::MarketUpdateAction(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MarketUpdateAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarketUpdateAction *arg1 = (FIX::MarketUpdateAction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MarketUpdateAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MarketUpdateAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarketUpdateAction" "', argument " "1"" of type '" "FIX::MarketUpdateAction *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MarketUpdateAction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MarketUpdateAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MarketUpdateAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CollAsgnRejectReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollAsgnRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollAsgnRejectReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollAsgnRejectReason *)new FIX::CollAsgnRejectReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollAsgnRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollAsgnRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollAsgnRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollAsgnRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollAsgnRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollAsgnRejectReason *)new FIX::CollAsgnRejectReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollAsgnRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollAsgnRejectReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollAsgnRejectReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollAsgnRejectReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollAsgnRejectReason::CollAsgnRejectReason()\n"
    "    FIX::CollAsgnRejectReason::CollAsgnRejectReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollAsgnRejectReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollAsgnRejectReason *arg1 = (FIX::CollAsgnRejectReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollAsgnRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollAsgnRejectReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollAsgnRejectReason" "', argument " "1"" of type '" "FIX::CollAsgnRejectReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollAsgnRejectReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CollAsgnRejectReason_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CollAsgnRejectReason, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PeggedRefPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PeggedRefPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PeggedRefPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PeggedRefPrice *)new FIX::PeggedRefPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PeggedRefPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PeggedRefPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PeggedRefPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PeggedRefPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PeggedRefPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PeggedRefPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PeggedRefPrice *)new FIX::PeggedRefPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PeggedRefPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PeggedRefPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PeggedRefPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PeggedRefPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PeggedRefPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PeggedRefPrice::PeggedRefPrice()\n"
    "    FIX::PeggedRefPrice::PeggedRefPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PeggedRefPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PeggedRefPrice *arg1 = (FIX::PeggedRefPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PeggedRefPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PeggedRefPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PeggedRefPrice" "', argument " "1"" of type '" "FIX::PeggedRefPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PeggedRefPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PeggedRefPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PeggedRefPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_IndividualAllocType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IndividualAllocType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IndividualAllocType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IndividualAllocType *)new FIX::IndividualAllocType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IndividualAllocType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndividualAllocType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IndividualAllocType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IndividualAllocType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IndividualAllocType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IndividualAllocType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IndividualAllocType *)new FIX::IndividualAllocType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IndividualAllocType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndividualAllocType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IndividualAllocType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IndividualAllocType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IndividualAllocType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IndividualAllocType::IndividualAllocType()\n"
    "    FIX::IndividualAllocType::IndividualAllocType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IndividualAllocType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IndividualAllocType *arg1 = (FIX::IndividualAllocType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IndividualAllocType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IndividualAllocType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IndividualAllocType" "', argument " "1"" of type '" "FIX::IndividualAllocType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IndividualAllocType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IndividualAllocType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__IndividualAllocType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EndCash__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EndCash *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EndCash")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EndCash *)new FIX::EndCash();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EndCash, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndCash__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EndCash *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EndCash",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EndCash" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EndCash" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EndCash *)new FIX::EndCash((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EndCash, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndCash(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EndCash__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EndCash__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EndCash'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EndCash::EndCash()\n"
    "    FIX::EndCash::EndCash(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EndCash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EndCash *arg1 = (FIX::EndCash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EndCash",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EndCash, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EndCash" "', argument " "1"" of type '" "FIX::EndCash *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EndCash * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EndCash_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EndCash, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EventText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EventText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EventText")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EventText *)new FIX::EventText();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EventText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EventText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EventText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EventText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EventText *)new FIX::EventText((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EventText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EventText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EventText__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EventText__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EventText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EventText::EventText()\n"
    "    FIX::EventText::EventText(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EventText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EventText *arg1 = (FIX::EventText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EventText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EventText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventText" "', argument " "1"" of type '" "FIX::EventText *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EventText * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EventText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EventText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExDate *)new FIX::ExDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExDate *)new FIX::ExDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExDate::ExDate()\n"
    "    FIX::ExDate::ExDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExDate *arg1 = (FIX::ExDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExDate" "', argument " "1"" of type '" "FIX::ExDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ExDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NestedPartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NestedPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NestedPartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NestedPartyIDSource *)new FIX::NestedPartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NestedPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NestedPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NestedPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NestedPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NestedPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NestedPartyIDSource *)new FIX::NestedPartyIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NestedPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NestedPartyIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NestedPartyIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NestedPartyIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NestedPartyIDSource::NestedPartyIDSource()\n"
    "    FIX::NestedPartyIDSource::NestedPartyIDSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NestedPartyIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NestedPartyIDSource *arg1 = (FIX::NestedPartyIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NestedPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NestedPartyIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NestedPartyIDSource" "', argument " "1"" of type '" "FIX::NestedPartyIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NestedPartyIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NestedPartyIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NestedPartyIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_GTBookingInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::GTBookingInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_GTBookingInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::GTBookingInst *)new FIX::GTBookingInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__GTBookingInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GTBookingInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::GTBookingInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_GTBookingInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GTBookingInst" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GTBookingInst" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::GTBookingInst *)new FIX::GTBookingInst((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__GTBookingInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GTBookingInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_GTBookingInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GTBookingInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GTBookingInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::GTBookingInst::GTBookingInst()\n"
    "    FIX::GTBookingInst::GTBookingInst(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GTBookingInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::GTBookingInst *arg1 = (FIX::GTBookingInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_GTBookingInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__GTBookingInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GTBookingInst" "', argument " "1"" of type '" "FIX::GTBookingInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::GTBookingInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GTBookingInst_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__GTBookingInst, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeValuationMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeValuationMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeValuationMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeValuationMethod *)new FIX::DerivativeValuationMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeValuationMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeValuationMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeValuationMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeValuationMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeValuationMethod" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeValuationMethod *)new FIX::DerivativeValuationMethod((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeValuationMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeValuationMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeValuationMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeValuationMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeValuationMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeValuationMethod::DerivativeValuationMethod()\n"
    "    FIX::DerivativeValuationMethod::DerivativeValuationMethod(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeValuationMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeValuationMethod *arg1 = (FIX::DerivativeValuationMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeValuationMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeValuationMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeValuationMethod" "', argument " "1"" of type '" "FIX::DerivativeValuationMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeValuationMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeValuationMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeValuationMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NumberOfOrders__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NumberOfOrders *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NumberOfOrders")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NumberOfOrders *)new FIX::NumberOfOrders();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NumberOfOrders, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumberOfOrders__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NumberOfOrders *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NumberOfOrders",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NumberOfOrders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NumberOfOrders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NumberOfOrders *)new FIX::NumberOfOrders((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NumberOfOrders, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumberOfOrders(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NumberOfOrders__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NumberOfOrders__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NumberOfOrders'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NumberOfOrders::NumberOfOrders()\n"
    "    FIX::NumberOfOrders::NumberOfOrders(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NumberOfOrders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NumberOfOrders *arg1 = (FIX::NumberOfOrders *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NumberOfOrders",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NumberOfOrders, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NumberOfOrders" "', argument " "1"" of type '" "FIX::NumberOfOrders *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NumberOfOrders * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NumberOfOrders_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NumberOfOrders, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TrdRepPartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdRepPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TrdRepPartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdRepPartyRole *)new FIX::TrdRepPartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdRepPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRepPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TrdRepPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TrdRepPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrdRepPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TrdRepPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdRepPartyRole *)new FIX::TrdRepPartyRole((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdRepPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRepPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TrdRepPartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdRepPartyRole__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TrdRepPartyRole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TrdRepPartyRole::TrdRepPartyRole()\n"
    "    FIX::TrdRepPartyRole::TrdRepPartyRole(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TrdRepPartyRole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdRepPartyRole *arg1 = (FIX::TrdRepPartyRole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TrdRepPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TrdRepPartyRole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrdRepPartyRole" "', argument " "1"" of type '" "FIX::TrdRepPartyRole *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TrdRepPartyRole * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TrdRepPartyRole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TrdRepPartyRole, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TriggerPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerPrice *)new FIX::TriggerPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerPrice *)new FIX::TriggerPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerPrice::TriggerPrice()\n"
    "    FIX::TriggerPrice::TriggerPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerPrice *arg1 = (FIX::TriggerPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerPrice" "', argument " "1"" of type '" "FIX::TriggerPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TriggerPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TriggerPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MDReportID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDReportID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDReportID *)new FIX::MDReportID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDReportID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDReportID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDReportID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDReportID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDReportID *)new FIX::MDReportID((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDReportID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDReportID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDReportID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDReportID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDReportID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDReportID::MDReportID()\n"
    "    FIX::MDReportID::MDReportID(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDReportID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDReportID *arg1 = (FIX::MDReportID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDReportID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDReportID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDReportID" "', argument " "1"" of type '" "FIX::MDReportID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDReportID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MDReportID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MDReportID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecondaryAllocID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryAllocID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryAllocID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryAllocID *)new FIX::SecondaryAllocID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryAllocID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryAllocID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryAllocID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryAllocID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryAllocID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryAllocID *)new FIX::SecondaryAllocID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryAllocID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryAllocID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryAllocID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryAllocID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryAllocID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryAllocID::SecondaryAllocID()\n"
    "    FIX::SecondaryAllocID::SecondaryAllocID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryAllocID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryAllocID *arg1 = (FIX::SecondaryAllocID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryAllocID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryAllocID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryAllocID" "', argument " "1"" of type '" "FIX::SecondaryAllocID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryAllocID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecondaryAllocID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecondaryAllocID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LeavesQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LeavesQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LeavesQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LeavesQty *)new FIX::LeavesQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LeavesQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LeavesQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LeavesQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LeavesQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LeavesQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LeavesQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LeavesQty *)new FIX::LeavesQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LeavesQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LeavesQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LeavesQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LeavesQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LeavesQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LeavesQty::LeavesQty()\n"
    "    FIX::LeavesQty::LeavesQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LeavesQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LeavesQty *arg1 = (FIX::LeavesQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LeavesQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LeavesQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LeavesQty" "', argument " "1"" of type '" "FIX::LeavesQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LeavesQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LeavesQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LeavesQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CardStartDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CardStartDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CardStartDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CardStartDate *)new FIX::CardStartDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CardStartDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardStartDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CardStartDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CardStartDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CardStartDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CardStartDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CardStartDate *)new FIX::CardStartDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CardStartDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CardStartDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CardStartDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CardStartDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CardStartDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CardStartDate::CardStartDate()\n"
    "    FIX::CardStartDate::CardStartDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CardStartDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CardStartDate *arg1 = (FIX::CardStartDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CardStartDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CardStartDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CardStartDate" "', argument " "1"" of type '" "FIX::CardStartDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CardStartDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CardStartDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CardStartDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegCoveredOrUncovered__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCoveredOrUncovered *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegCoveredOrUncovered")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCoveredOrUncovered *)new FIX::LegCoveredOrUncovered();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCoveredOrUncovered, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCoveredOrUncovered__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegCoveredOrUncovered *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegCoveredOrUncovered",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegCoveredOrUncovered" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegCoveredOrUncovered" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCoveredOrUncovered *)new FIX::LegCoveredOrUncovered((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCoveredOrUncovered, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCoveredOrUncovered(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegCoveredOrUncovered__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCoveredOrUncovered__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegCoveredOrUncovered'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegCoveredOrUncovered::LegCoveredOrUncovered()\n"
    "    FIX::LegCoveredOrUncovered::LegCoveredOrUncovered(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegCoveredOrUncovered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCoveredOrUncovered *arg1 = (FIX::LegCoveredOrUncovered *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegCoveredOrUncovered",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegCoveredOrUncovered, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegCoveredOrUncovered" "', argument " "1"" of type '" "FIX::LegCoveredOrUncovered *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegCoveredOrUncovered * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegCoveredOrUncovered_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegCoveredOrUncovered, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PutOrCall__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PutOrCall *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PutOrCall")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PutOrCall *)new FIX::PutOrCall();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PutOrCall, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PutOrCall__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PutOrCall *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PutOrCall",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PutOrCall *)new FIX::PutOrCall((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PutOrCall, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PutOrCall(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PutOrCall__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PutOrCall__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PutOrCall'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PutOrCall::PutOrCall()\n"
    "    FIX::PutOrCall::PutOrCall(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PutOrCall(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PutOrCall *arg1 = (FIX::PutOrCall *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PutOrCall",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PutOrCall, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PutOrCall" "', argument " "1"" of type '" "FIX::PutOrCall *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PutOrCall * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PutOrCall_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PutOrCall, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MatchAlgorithm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MatchAlgorithm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MatchAlgorithm")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MatchAlgorithm *)new FIX::MatchAlgorithm();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MatchAlgorithm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchAlgorithm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MatchAlgorithm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MatchAlgorithm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatchAlgorithm" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatchAlgorithm" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MatchAlgorithm *)new FIX::MatchAlgorithm((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MatchAlgorithm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchAlgorithm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MatchAlgorithm__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MatchAlgorithm__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MatchAlgorithm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MatchAlgorithm::MatchAlgorithm()\n"
    "    FIX::MatchAlgorithm::MatchAlgorithm(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MatchAlgorithm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MatchAlgorithm *arg1 = (FIX::MatchAlgorithm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MatchAlgorithm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MatchAlgorithm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MatchAlgorithm" "', argument " "1"" of type '" "FIX::MatchAlgorithm *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MatchAlgorithm * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MatchAlgorithm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MatchAlgorithm, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CalculatedCcyLastQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CalculatedCcyLastQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CalculatedCcyLastQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CalculatedCcyLastQty *)new FIX::CalculatedCcyLastQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CalculatedCcyLastQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalculatedCcyLastQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CalculatedCcyLastQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CalculatedCcyLastQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CalculatedCcyLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CalculatedCcyLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CalculatedCcyLastQty *)new FIX::CalculatedCcyLastQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CalculatedCcyLastQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CalculatedCcyLastQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CalculatedCcyLastQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CalculatedCcyLastQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CalculatedCcyLastQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CalculatedCcyLastQty::CalculatedCcyLastQty()\n"
    "    FIX::CalculatedCcyLastQty::CalculatedCcyLastQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CalculatedCcyLastQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CalculatedCcyLastQty *arg1 = (FIX::CalculatedCcyLastQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CalculatedCcyLastQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CalculatedCcyLastQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CalculatedCcyLastQty" "', argument " "1"" of type '" "FIX::CalculatedCcyLastQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CalculatedCcyLastQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CalculatedCcyLastQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CalculatedCcyLastQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FundRenewWaiv__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FundRenewWaiv *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FundRenewWaiv")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FundRenewWaiv *)new FIX::FundRenewWaiv();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FundRenewWaiv, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FundRenewWaiv__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FundRenewWaiv *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FundRenewWaiv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FundRenewWaiv" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FundRenewWaiv" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FundRenewWaiv *)new FIX::FundRenewWaiv((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FundRenewWaiv, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FundRenewWaiv(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FundRenewWaiv__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FundRenewWaiv__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FundRenewWaiv'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FundRenewWaiv::FundRenewWaiv()\n"
    "    FIX::FundRenewWaiv::FundRenewWaiv(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FundRenewWaiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FundRenewWaiv *arg1 = (FIX::FundRenewWaiv *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FundRenewWaiv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FundRenewWaiv, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FundRenewWaiv" "', argument " "1"" of type '" "FIX::FundRenewWaiv *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FundRenewWaiv * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FundRenewWaiv_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FundRenewWaiv, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecuritySettlAgentName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecuritySettlAgentName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecuritySettlAgentName *)new FIX::SecuritySettlAgentName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecuritySettlAgentName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecuritySettlAgentName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecuritySettlAgentName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecuritySettlAgentName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecuritySettlAgentName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecuritySettlAgentName *)new FIX::SecuritySettlAgentName((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecuritySettlAgentName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecuritySettlAgentName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecuritySettlAgentName__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecuritySettlAgentName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecuritySettlAgentName::SecuritySettlAgentName()\n"
    "    FIX::SecuritySettlAgentName::SecuritySettlAgentName(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecuritySettlAgentName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecuritySettlAgentName *arg1 = (FIX::SecuritySettlAgentName *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecuritySettlAgentName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecuritySettlAgentName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecuritySettlAgentName" "', argument " "1"" of type '" "FIX::SecuritySettlAgentName *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecuritySettlAgentName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecuritySettlAgentName_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecuritySettlAgentName, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BidDescriptor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidDescriptor *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BidDescriptor")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidDescriptor *)new FIX::BidDescriptor();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidDescriptor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidDescriptor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BidDescriptor *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BidDescriptor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BidDescriptor" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BidDescriptor" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidDescriptor *)new FIX::BidDescriptor((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidDescriptor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidDescriptor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BidDescriptor__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidDescriptor__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BidDescriptor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BidDescriptor::BidDescriptor()\n"
    "    FIX::BidDescriptor::BidDescriptor(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BidDescriptor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidDescriptor *arg1 = (FIX::BidDescriptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BidDescriptor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BidDescriptor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BidDescriptor" "', argument " "1"" of type '" "FIX::BidDescriptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BidDescriptor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BidDescriptor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BidDescriptor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MDStreamID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDStreamID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDStreamID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDStreamID *)new FIX::MDStreamID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDStreamID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDStreamID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDStreamID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDStreamID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDStreamID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDStreamID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDStreamID *)new FIX::MDStreamID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDStreamID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDStreamID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDStreamID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDStreamID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDStreamID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDStreamID::MDStreamID()\n"
    "    FIX::MDStreamID::MDStreamID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDStreamID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDStreamID *arg1 = (FIX::MDStreamID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDStreamID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDStreamID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDStreamID" "', argument " "1"" of type '" "FIX::MDStreamID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDStreamID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MDStreamID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MDStreamID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoAsgnReqs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoAsgnReqs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoAsgnReqs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoAsgnReqs *)new FIX::NoAsgnReqs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoAsgnReqs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAsgnReqs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoAsgnReqs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoAsgnReqs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoAsgnReqs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoAsgnReqs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoAsgnReqs *)new FIX::NoAsgnReqs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoAsgnReqs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAsgnReqs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoAsgnReqs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoAsgnReqs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoAsgnReqs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoAsgnReqs::NoAsgnReqs()\n"
    "    FIX::NoAsgnReqs::NoAsgnReqs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoAsgnReqs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoAsgnReqs *arg1 = (FIX::NoAsgnReqs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoAsgnReqs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoAsgnReqs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoAsgnReqs" "', argument " "1"" of type '" "FIX::NoAsgnReqs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoAsgnReqs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoAsgnReqs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoAsgnReqs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NotionalPercentageOutstanding__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NotionalPercentageOutstanding *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NotionalPercentageOutstanding")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NotionalPercentageOutstanding *)new FIX::NotionalPercentageOutstanding();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NotionalPercentageOutstanding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotionalPercentageOutstanding__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NotionalPercentageOutstanding *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NotionalPercentageOutstanding",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NotionalPercentageOutstanding *)new FIX::NotionalPercentageOutstanding((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NotionalPercentageOutstanding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotionalPercentageOutstanding(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NotionalPercentageOutstanding__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NotionalPercentageOutstanding__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NotionalPercentageOutstanding'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NotionalPercentageOutstanding::NotionalPercentageOutstanding()\n"
    "    FIX::NotionalPercentageOutstanding::NotionalPercentageOutstanding(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NotionalPercentageOutstanding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NotionalPercentageOutstanding *arg1 = (FIX::NotionalPercentageOutstanding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NotionalPercentageOutstanding",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NotionalPercentageOutstanding, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::NotionalPercentageOutstanding *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NotionalPercentageOutstanding * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NotionalPercentageOutstanding_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NotionalPercentageOutstanding, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoSettlInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSettlInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoSettlInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSettlInst *)new FIX::NoSettlInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSettlInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoSettlInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoSettlInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoSettlInst" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoSettlInst" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSettlInst *)new FIX::NoSettlInst((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSettlInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoSettlInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSettlInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoSettlInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoSettlInst::NoSettlInst()\n"
    "    FIX::NoSettlInst::NoSettlInst(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoSettlInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSettlInst *arg1 = (FIX::NoSettlInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoSettlInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoSettlInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoSettlInst" "', argument " "1"" of type '" "FIX::NoSettlInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoSettlInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoSettlInst_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoSettlInst, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlInstMsgID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstMsgID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlInstMsgID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstMsgID *)new FIX::SettlInstMsgID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstMsgID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstMsgID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlInstMsgID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlInstMsgID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlInstMsgID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlInstMsgID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlInstMsgID *)new FIX::SettlInstMsgID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlInstMsgID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlInstMsgID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlInstMsgID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlInstMsgID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlInstMsgID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlInstMsgID::SettlInstMsgID()\n"
    "    FIX::SettlInstMsgID::SettlInstMsgID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlInstMsgID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlInstMsgID *arg1 = (FIX::SettlInstMsgID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlInstMsgID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlInstMsgID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlInstMsgID" "', argument " "1"" of type '" "FIX::SettlInstMsgID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlInstMsgID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlInstMsgID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlInstMsgID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ForexReq__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ForexReq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ForexReq")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ForexReq *)new FIX::ForexReq();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ForexReq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForexReq__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ForexReq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ForexReq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ForexReq" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ForexReq" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ForexReq *)new FIX::ForexReq((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ForexReq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ForexReq(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ForexReq__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ForexReq__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ForexReq'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ForexReq::ForexReq()\n"
    "    FIX::ForexReq::ForexReq(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ForexReq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ForexReq *arg1 = (FIX::ForexReq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ForexReq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ForexReq, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ForexReq" "', argument " "1"" of type '" "FIX::ForexReq *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ForexReq * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ForexReq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ForexReq, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradSesReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradSesReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesReqID *)new FIX::TradSesReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesReqID *)new FIX::TradSesReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradSesReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradSesReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradSesReqID::TradSesReqID()\n"
    "    FIX::TradSesReqID::TradSesReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradSesReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesReqID *arg1 = (FIX::TradSesReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradSesReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradSesReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradSesReqID" "', argument " "1"" of type '" "FIX::TradSesReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradSesReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradSesReqID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradSesReqID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingLegStrikePrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegStrikePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegStrikePrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegStrikePrice *)new FIX::UnderlyingLegStrikePrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegStrikePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegStrikePrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegStrikePrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegStrikePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegStrikePrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegStrikePrice *)new FIX::UnderlyingLegStrikePrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegStrikePrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegStrikePrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegStrikePrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegStrikePrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegStrikePrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegStrikePrice::UnderlyingLegStrikePrice()\n"
    "    FIX::UnderlyingLegStrikePrice::UnderlyingLegStrikePrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegStrikePrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegStrikePrice *arg1 = (FIX::UnderlyingLegStrikePrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegStrikePrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegStrikePrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegStrikePrice" "', argument " "1"" of type '" "FIX::UnderlyingLegStrikePrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegStrikePrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingLegStrikePrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingLegStrikePrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TickRuleType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TickRuleType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TickRuleType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TickRuleType *)new FIX::TickRuleType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TickRuleType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TickRuleType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TickRuleType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TickRuleType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TickRuleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TickRuleType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TickRuleType *)new FIX::TickRuleType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TickRuleType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TickRuleType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TickRuleType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TickRuleType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TickRuleType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TickRuleType::TickRuleType()\n"
    "    FIX::TickRuleType::TickRuleType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TickRuleType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TickRuleType *arg1 = (FIX::TickRuleType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TickRuleType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TickRuleType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TickRuleType" "', argument " "1"" of type '" "FIX::TickRuleType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TickRuleType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TickRuleType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TickRuleType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_InstrmtAssignmentMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrmtAssignmentMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InstrmtAssignmentMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrmtAssignmentMethod *)new FIX::InstrmtAssignmentMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrmtAssignmentMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrmtAssignmentMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InstrmtAssignmentMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InstrmtAssignmentMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstrmtAssignmentMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InstrmtAssignmentMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrmtAssignmentMethod *)new FIX::InstrmtAssignmentMethod((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrmtAssignmentMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrmtAssignmentMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InstrmtAssignmentMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrmtAssignmentMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InstrmtAssignmentMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InstrmtAssignmentMethod::InstrmtAssignmentMethod()\n"
    "    FIX::InstrmtAssignmentMethod::InstrmtAssignmentMethod(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InstrmtAssignmentMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrmtAssignmentMethod *arg1 = (FIX::InstrmtAssignmentMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InstrmtAssignmentMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InstrmtAssignmentMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InstrmtAssignmentMethod" "', argument " "1"" of type '" "FIX::InstrmtAssignmentMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InstrmtAssignmentMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InstrmtAssignmentMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__InstrmtAssignmentMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DiscretionOffsetType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionOffsetType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DiscretionOffsetType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionOffsetType *)new FIX::DiscretionOffsetType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionOffsetType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionOffsetType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DiscretionOffsetType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DiscretionOffsetType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscretionOffsetType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretionOffsetType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionOffsetType *)new FIX::DiscretionOffsetType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionOffsetType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionOffsetType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DiscretionOffsetType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionOffsetType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DiscretionOffsetType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DiscretionOffsetType::DiscretionOffsetType()\n"
    "    FIX::DiscretionOffsetType::DiscretionOffsetType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DiscretionOffsetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionOffsetType *arg1 = (FIX::DiscretionOffsetType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DiscretionOffsetType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DiscretionOffsetType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscretionOffsetType" "', argument " "1"" of type '" "FIX::DiscretionOffsetType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DiscretionOffsetType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DiscretionOffsetType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DiscretionOffsetType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ConfirmTransType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfirmTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ConfirmTransType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfirmTransType *)new FIX::ConfirmTransType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfirmTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ConfirmTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ConfirmTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfirmTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConfirmTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ConfirmTransType *)new FIX::ConfirmTransType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ConfirmTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConfirmTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ConfirmTransType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConfirmTransType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ConfirmTransType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ConfirmTransType::ConfirmTransType()\n"
    "    FIX::ConfirmTransType::ConfirmTransType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ConfirmTransType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ConfirmTransType *arg1 = (FIX::ConfirmTransType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ConfirmTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ConfirmTransType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfirmTransType" "', argument " "1"" of type '" "FIX::ConfirmTransType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ConfirmTransType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConfirmTransType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ConfirmTransType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TotalTakedown__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalTakedown *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotalTakedown")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalTakedown *)new FIX::TotalTakedown();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalTakedown, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalTakedown__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotalTakedown *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotalTakedown",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotalTakedown" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotalTakedown" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalTakedown *)new FIX::TotalTakedown((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalTakedown, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalTakedown(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotalTakedown__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalTakedown__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotalTakedown'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotalTakedown::TotalTakedown()\n"
    "    FIX::TotalTakedown::TotalTakedown(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotalTakedown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalTakedown *arg1 = (FIX::TotalTakedown *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotalTakedown",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotalTakedown, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotalTakedown" "', argument " "1"" of type '" "FIX::TotalTakedown *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotalTakedown * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TotalTakedown_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TotalTakedown, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResponseDestination__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ResponseDestination *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ResponseDestination")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ResponseDestination *)new FIX::ResponseDestination();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ResponseDestination, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResponseDestination__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ResponseDestination *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResponseDestination",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ResponseDestination" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ResponseDestination" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ResponseDestination *)new FIX::ResponseDestination((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ResponseDestination, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResponseDestination(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ResponseDestination__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ResponseDestination__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ResponseDestination'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ResponseDestination::ResponseDestination()\n"
    "    FIX::ResponseDestination::ResponseDestination(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ResponseDestination(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ResponseDestination *arg1 = (FIX::ResponseDestination *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResponseDestination",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ResponseDestination, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResponseDestination" "', argument " "1"" of type '" "FIX::ResponseDestination *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ResponseDestination * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResponseDestination_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ResponseDestination, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MDSecSizeType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDSecSizeType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDSecSizeType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDSecSizeType *)new FIX::MDSecSizeType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDSecSizeType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDSecSizeType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDSecSizeType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDSecSizeType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDSecSizeType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDSecSizeType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDSecSizeType *)new FIX::MDSecSizeType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDSecSizeType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDSecSizeType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDSecSizeType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDSecSizeType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDSecSizeType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDSecSizeType::MDSecSizeType()\n"
    "    FIX::MDSecSizeType::MDSecSizeType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDSecSizeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDSecSizeType *arg1 = (FIX::MDSecSizeType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDSecSizeType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDSecSizeType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDSecSizeType" "', argument " "1"" of type '" "FIX::MDSecSizeType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDSecSizeType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MDSecSizeType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MDSecSizeType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_InstrumentPartySubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrumentPartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InstrumentPartySubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrumentPartySubIDType *)new FIX::InstrumentPartySubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrumentPartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InstrumentPartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InstrumentPartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrumentPartySubIDType *)new FIX::InstrumentPartySubIDType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrumentPartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InstrumentPartySubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrumentPartySubIDType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InstrumentPartySubIDType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InstrumentPartySubIDType::InstrumentPartySubIDType()\n"
    "    FIX::InstrumentPartySubIDType::InstrumentPartySubIDType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InstrumentPartySubIDType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrumentPartySubIDType *arg1 = (FIX::InstrumentPartySubIDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InstrumentPartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InstrumentPartySubIDType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InstrumentPartySubIDType" "', argument " "1"" of type '" "FIX::InstrumentPartySubIDType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InstrumentPartySubIDType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InstrumentPartySubIDType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__InstrumentPartySubIDType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegTimeUnit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegTimeUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegTimeUnit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegTimeUnit *)new FIX::LegTimeUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegTimeUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegTimeUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegTimeUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegTimeUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegTimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegTimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegTimeUnit *)new FIX::LegTimeUnit((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegTimeUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegTimeUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegTimeUnit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegTimeUnit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegTimeUnit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegTimeUnit::LegTimeUnit()\n"
    "    FIX::LegTimeUnit::LegTimeUnit(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegTimeUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegTimeUnit *arg1 = (FIX::LegTimeUnit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegTimeUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegTimeUnit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegTimeUnit" "', argument " "1"" of type '" "FIX::LegTimeUnit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegTimeUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegTimeUnit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegTimeUnit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TransferReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TransferReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TransferReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TransferReason *)new FIX::TransferReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TransferReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransferReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TransferReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TransferReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransferReason" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TransferReason" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TransferReason *)new FIX::TransferReason((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TransferReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TransferReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TransferReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TransferReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TransferReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TransferReason::TransferReason()\n"
    "    FIX::TransferReason::TransferReason(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TransferReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TransferReason *arg1 = (FIX::TransferReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TransferReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TransferReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransferReason" "', argument " "1"" of type '" "FIX::TransferReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TransferReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TransferReason_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TransferReason, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ApplQueueMax__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplQueueMax *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplQueueMax")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplQueueMax *)new FIX::ApplQueueMax();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplQueueMax, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueMax__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplQueueMax *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplQueueMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplQueueMax" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplQueueMax" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplQueueMax *)new FIX::ApplQueueMax((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplQueueMax, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueMax(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplQueueMax__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplQueueMax__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplQueueMax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplQueueMax::ApplQueueMax()\n"
    "    FIX::ApplQueueMax::ApplQueueMax(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplQueueMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplQueueMax *arg1 = (FIX::ApplQueueMax *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplQueueMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplQueueMax, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplQueueMax" "', argument " "1"" of type '" "FIX::ApplQueueMax *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplQueueMax * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ApplQueueMax_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ApplQueueMax, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DiscretionOffsetValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionOffsetValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DiscretionOffsetValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionOffsetValue *)new FIX::DiscretionOffsetValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionOffsetValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionOffsetValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DiscretionOffsetValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DiscretionOffsetValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscretionOffsetValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretionOffsetValue" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionOffsetValue *)new FIX::DiscretionOffsetValue((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionOffsetValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionOffsetValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DiscretionOffsetValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionOffsetValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DiscretionOffsetValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DiscretionOffsetValue::DiscretionOffsetValue()\n"
    "    FIX::DiscretionOffsetValue::DiscretionOffsetValue(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DiscretionOffsetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionOffsetValue *arg1 = (FIX::DiscretionOffsetValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DiscretionOffsetValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DiscretionOffsetValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscretionOffsetValue" "', argument " "1"" of type '" "FIX::DiscretionOffsetValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DiscretionOffsetValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DiscretionOffsetValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DiscretionOffsetValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BookingRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BookingRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BookingRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BookingRefID *)new FIX::BookingRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BookingRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BookingRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BookingRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BookingRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BookingRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BookingRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BookingRefID *)new FIX::BookingRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BookingRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BookingRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BookingRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BookingRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BookingRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BookingRefID::BookingRefID()\n"
    "    FIX::BookingRefID::BookingRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BookingRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BookingRefID *arg1 = (FIX::BookingRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BookingRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BookingRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BookingRefID" "', argument " "1"" of type '" "FIX::BookingRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BookingRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BookingRefID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BookingRefID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegBidPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegBidPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegBidPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegBidPx *)new FIX::LegBidPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegBidPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBidPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegBidPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegBidPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegBidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegBidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegBidPx *)new FIX::LegBidPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegBidPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBidPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegBidPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegBidPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegBidPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegBidPx::LegBidPx()\n"
    "    FIX::LegBidPx::LegBidPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegBidPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegBidPx *arg1 = (FIX::LegBidPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegBidPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegBidPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegBidPx" "', argument " "1"" of type '" "FIX::LegBidPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegBidPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegBidPx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegBidPx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradSesEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesEvent *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradSesEvent")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesEvent *)new FIX::TradSesEvent();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesEvent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesEvent *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesEvent" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesEvent" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesEvent *)new FIX::TradSesEvent((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesEvent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesEvent(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradSesEvent__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesEvent__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradSesEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradSesEvent::TradSesEvent()\n"
    "    FIX::TradSesEvent::TradSesEvent(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradSesEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesEvent *arg1 = (FIX::TradSesEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradSesEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradSesEvent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradSesEvent" "', argument " "1"" of type '" "FIX::TradSesEvent *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradSesEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradSesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradSesEvent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeProduct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeProduct *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeProduct")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeProduct *)new FIX::DerivativeProduct();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeProduct, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeProduct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeProduct *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeProduct",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeProduct" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeProduct" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeProduct *)new FIX::DerivativeProduct((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeProduct, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeProduct(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeProduct__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeProduct__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeProduct'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeProduct::DerivativeProduct()\n"
    "    FIX::DerivativeProduct::DerivativeProduct(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeProduct *arg1 = (FIX::DerivativeProduct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeProduct",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeProduct, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeProduct" "', argument " "1"" of type '" "FIX::DerivativeProduct *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeProduct * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeProduct_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeProduct, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RootPartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RootPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RootPartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RootPartyRole *)new FIX::RootPartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RootPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RootPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RootPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RootPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RootPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RootPartyRole *)new FIX::RootPartyRole((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RootPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RootPartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RootPartyRole__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RootPartyRole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RootPartyRole::RootPartyRole()\n"
    "    FIX::RootPartyRole::RootPartyRole(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RootPartyRole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RootPartyRole *arg1 = (FIX::RootPartyRole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RootPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RootPartyRole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RootPartyRole" "', argument " "1"" of type '" "FIX::RootPartyRole *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RootPartyRole * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RootPartyRole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RootPartyRole, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DlvyInstType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DlvyInstType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DlvyInstType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DlvyInstType *)new FIX::DlvyInstType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DlvyInstType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DlvyInstType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DlvyInstType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DlvyInstType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DlvyInstType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DlvyInstType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DlvyInstType *)new FIX::DlvyInstType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DlvyInstType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DlvyInstType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DlvyInstType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DlvyInstType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DlvyInstType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DlvyInstType::DlvyInstType()\n"
    "    FIX::DlvyInstType::DlvyInstType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DlvyInstType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DlvyInstType *arg1 = (FIX::DlvyInstType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DlvyInstType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DlvyInstType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DlvyInstType" "', argument " "1"" of type '" "FIX::DlvyInstType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DlvyInstType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DlvyInstType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DlvyInstType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoLinesOfText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoLinesOfText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoLinesOfText")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoLinesOfText *)new FIX::NoLinesOfText();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoLinesOfText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLinesOfText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoLinesOfText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoLinesOfText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoLinesOfText" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoLinesOfText" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoLinesOfText *)new FIX::NoLinesOfText((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoLinesOfText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoLinesOfText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoLinesOfText__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoLinesOfText__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoLinesOfText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoLinesOfText::NoLinesOfText()\n"
    "    FIX::NoLinesOfText::NoLinesOfText(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoLinesOfText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoLinesOfText *arg1 = (FIX::NoLinesOfText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoLinesOfText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoLinesOfText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoLinesOfText" "', argument " "1"" of type '" "FIX::NoLinesOfText *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoLinesOfText * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoLinesOfText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoLinesOfText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PosReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PosReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosReqID *)new FIX::PosReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PosReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PosReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PosReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PosReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosReqID *)new FIX::PosReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PosReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PosReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PosReqID::PosReqID()\n"
    "    FIX::PosReqID::PosReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PosReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosReqID *arg1 = (FIX::PosReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PosReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PosReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PosReqID" "', argument " "1"" of type '" "FIX::PosReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PosReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PosReqID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PosReqID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegSecurityAltIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecurityAltIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSecurityAltIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecurityAltIDSource *)new FIX::LegSecurityAltIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecurityAltIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityAltIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSecurityAltIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSecurityAltIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSecurityAltIDSource *)new FIX::LegSecurityAltIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSecurityAltIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSecurityAltIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSecurityAltIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSecurityAltIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSecurityAltIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSecurityAltIDSource::LegSecurityAltIDSource()\n"
    "    FIX::LegSecurityAltIDSource::LegSecurityAltIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSecurityAltIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSecurityAltIDSource *arg1 = (FIX::LegSecurityAltIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSecurityAltIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSecurityAltIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSecurityAltIDSource" "', argument " "1"" of type '" "FIX::LegSecurityAltIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSecurityAltIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegSecurityAltIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegSecurityAltIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncodedSubject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedSubject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedSubject")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSubject *)new FIX::EncodedSubject();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSubject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSubject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedSubject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedSubject",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedSubject" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedSubject" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSubject *)new FIX::EncodedSubject((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSubject, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSubject(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedSubject__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedSubject__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedSubject'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedSubject::EncodedSubject()\n"
    "    FIX::EncodedSubject::EncodedSubject(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedSubject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedSubject *arg1 = (FIX::EncodedSubject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedSubject",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedSubject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedSubject" "', argument " "1"" of type '" "FIX::EncodedSubject *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedSubject * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncodedSubject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedSubject, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ContraBroker__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContraBroker *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ContraBroker")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContraBroker *)new FIX::ContraBroker();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContraBroker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraBroker__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContraBroker *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContraBroker",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContraBroker" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContraBroker" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContraBroker *)new FIX::ContraBroker((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContraBroker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraBroker(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ContraBroker__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContraBroker__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContraBroker'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ContraBroker::ContraBroker()\n"
    "    FIX::ContraBroker::ContraBroker(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ContraBroker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContraBroker *arg1 = (FIX::ContraBroker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContraBroker",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ContraBroker, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContraBroker" "', argument " "1"" of type '" "FIX::ContraBroker *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ContraBroker * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ContraBroker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ContraBroker, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradeCondition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeCondition *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeCondition")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeCondition *)new FIX::TradeCondition();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeCondition, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeCondition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLESTRINGVALUE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeCondition *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeCondition",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeCondition" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeCondition" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLESTRINGVALUE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeCondition *)new FIX::TradeCondition((FIX::MULTIPLESTRINGVALUE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeCondition, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeCondition(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeCondition__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeCondition__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeCondition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeCondition::TradeCondition()\n"
    "    FIX::TradeCondition::TradeCondition(FIX::MULTIPLESTRINGVALUE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeCondition *arg1 = (FIX::TradeCondition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeCondition",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeCondition, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeCondition" "', argument " "1"" of type '" "FIX::TradeCondition *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeCondition * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradeCondition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradeCondition, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyID *)new FIX::PartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyID *)new FIX::PartyID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartyID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PartyID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PartyID::PartyID()\n"
    "    FIX::PartyID::PartyID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PartyID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyID *arg1 = (FIX::PartyID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PartyID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PartyID" "', argument " "1"" of type '" "FIX::PartyID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PartyID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PartyID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PartyID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MDEntryID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDEntryID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryID *)new FIX::MDEntryID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDEntryID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDEntryID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDEntryID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDEntryID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryID *)new FIX::MDEntryID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDEntryID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDEntryID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDEntryID::MDEntryID()\n"
    "    FIX::MDEntryID::MDEntryID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDEntryID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryID *arg1 = (FIX::MDEntryID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDEntryID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDEntryID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDEntryID" "', argument " "1"" of type '" "FIX::MDEntryID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDEntryID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MDEntryID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MDEntryID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityExchange__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecurityExchange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegSecurityExchange")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecurityExchange *)new FIX::UnderlyingLegSecurityExchange();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecurityExchange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityExchange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegSecurityExchange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegSecurityExchange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegSecurityExchange" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegSecurityExchange" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecurityExchange *)new FIX::UnderlyingLegSecurityExchange((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecurityExchange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityExchange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegSecurityExchange__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecurityExchange__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegSecurityExchange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegSecurityExchange::UnderlyingLegSecurityExchange()\n"
    "    FIX::UnderlyingLegSecurityExchange::UnderlyingLegSecurityExchange(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegSecurityExchange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecurityExchange *arg1 = (FIX::UnderlyingLegSecurityExchange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegSecurityExchange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegSecurityExchange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegSecurityExchange" "', argument " "1"" of type '" "FIX::UnderlyingLegSecurityExchange *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegSecurityExchange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingLegSecurityExchange_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityExchange, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PriceLimitType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceLimitType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PriceLimitType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceLimitType *)new FIX::PriceLimitType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceLimitType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceLimitType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PriceLimitType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PriceLimitType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PriceLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PriceLimitType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceLimitType *)new FIX::PriceLimitType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceLimitType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceLimitType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PriceLimitType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceLimitType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PriceLimitType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PriceLimitType::PriceLimitType()\n"
    "    FIX::PriceLimitType::PriceLimitType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PriceLimitType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceLimitType *arg1 = (FIX::PriceLimitType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PriceLimitType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PriceLimitType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PriceLimitType" "', argument " "1"" of type '" "FIX::PriceLimitType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PriceLimitType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PriceLimitType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PriceLimitType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TriggerSecurityIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerSecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerSecurityIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerSecurityIDSource *)new FIX::TriggerSecurityIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerSecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerSecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerSecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerSecurityIDSource *)new FIX::TriggerSecurityIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerSecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerSecurityIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerSecurityIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerSecurityIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerSecurityIDSource::TriggerSecurityIDSource()\n"
    "    FIX::TriggerSecurityIDSource::TriggerSecurityIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerSecurityIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerSecurityIDSource *arg1 = (FIX::TriggerSecurityIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerSecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerSecurityIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerSecurityIDSource" "', argument " "1"" of type '" "FIX::TriggerSecurityIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerSecurityIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TriggerSecurityIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TriggerSecurityIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoUndlyInstrumentPartySubIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoUndlyInstrumentPartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoUndlyInstrumentPartySubIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoUndlyInstrumentPartySubIDs *)new FIX::NoUndlyInstrumentPartySubIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoUndlyInstrumentPartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUndlyInstrumentPartySubIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoUndlyInstrumentPartySubIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoUndlyInstrumentPartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoUndlyInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoUndlyInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoUndlyInstrumentPartySubIDs *)new FIX::NoUndlyInstrumentPartySubIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoUndlyInstrumentPartySubIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUndlyInstrumentPartySubIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoUndlyInstrumentPartySubIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoUndlyInstrumentPartySubIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoUndlyInstrumentPartySubIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoUndlyInstrumentPartySubIDs::NoUndlyInstrumentPartySubIDs()\n"
    "    FIX::NoUndlyInstrumentPartySubIDs::NoUndlyInstrumentPartySubIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoUndlyInstrumentPartySubIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoUndlyInstrumentPartySubIDs *arg1 = (FIX::NoUndlyInstrumentPartySubIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoUndlyInstrumentPartySubIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoUndlyInstrumentPartySubIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoUndlyInstrumentPartySubIDs" "', argument " "1"" of type '" "FIX::NoUndlyInstrumentPartySubIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoUndlyInstrumentPartySubIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoUndlyInstrumentPartySubIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoUndlyInstrumentPartySubIDs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ClientBidID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClientBidID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ClientBidID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClientBidID *)new FIX::ClientBidID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClientBidID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClientBidID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ClientBidID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ClientBidID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClientBidID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ClientBidID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ClientBidID *)new FIX::ClientBidID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ClientBidID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClientBidID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ClientBidID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClientBidID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ClientBidID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ClientBidID::ClientBidID()\n"
    "    FIX::ClientBidID::ClientBidID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ClientBidID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ClientBidID *arg1 = (FIX::ClientBidID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ClientBidID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ClientBidID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClientBidID" "', argument " "1"" of type '" "FIX::ClientBidID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ClientBidID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ClientBidID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ClientBidID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NetChgPrevDay__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NetChgPrevDay *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NetChgPrevDay")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NetChgPrevDay *)new FIX::NetChgPrevDay();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NetChgPrevDay, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetChgPrevDay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NetChgPrevDay *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NetChgPrevDay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NetChgPrevDay" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NetChgPrevDay" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NetChgPrevDay *)new FIX::NetChgPrevDay((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NetChgPrevDay, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetChgPrevDay(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NetChgPrevDay__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NetChgPrevDay__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NetChgPrevDay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NetChgPrevDay::NetChgPrevDay()\n"
    "    FIX::NetChgPrevDay::NetChgPrevDay(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NetChgPrevDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NetChgPrevDay *arg1 = (FIX::NetChgPrevDay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NetChgPrevDay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NetChgPrevDay, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NetChgPrevDay" "', argument " "1"" of type '" "FIX::NetChgPrevDay *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NetChgPrevDay * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NetChgPrevDay_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NetChgPrevDay, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DefaultApplVerID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DefaultApplVerID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DefaultApplVerID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DefaultApplVerID *)new FIX::DefaultApplVerID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DefaultApplVerID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultApplVerID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DefaultApplVerID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DefaultApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DefaultApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DefaultApplVerID *)new FIX::DefaultApplVerID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DefaultApplVerID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultApplVerID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DefaultApplVerID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefaultApplVerID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DefaultApplVerID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DefaultApplVerID::DefaultApplVerID()\n"
    "    FIX::DefaultApplVerID::DefaultApplVerID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DefaultApplVerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DefaultApplVerID *arg1 = (FIX::DefaultApplVerID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DefaultApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DefaultApplVerID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultApplVerID" "', argument " "1"" of type '" "FIX::DefaultApplVerID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DefaultApplVerID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefaultApplVerID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DefaultApplVerID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_IOIID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IOIID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIID *)new FIX::IOIID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IOIID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IOIID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOIID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IOIID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIID *)new FIX::IOIID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IOIID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IOIID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IOIID::IOIID()\n"
    "    FIX::IOIID::IOIID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IOIID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIID *arg1 = (FIX::IOIID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IOIID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IOIID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOIID" "', argument " "1"" of type '" "FIX::IOIID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IOIID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IOIID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__IOIID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SpreadToBenchmark__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SpreadToBenchmark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SpreadToBenchmark")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SpreadToBenchmark *)new FIX::SpreadToBenchmark();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SpreadToBenchmark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadToBenchmark__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SpreadToBenchmark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SpreadToBenchmark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpreadToBenchmark" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpreadToBenchmark" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SpreadToBenchmark *)new FIX::SpreadToBenchmark((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SpreadToBenchmark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpreadToBenchmark(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SpreadToBenchmark__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpreadToBenchmark__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SpreadToBenchmark'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SpreadToBenchmark::SpreadToBenchmark()\n"
    "    FIX::SpreadToBenchmark::SpreadToBenchmark(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SpreadToBenchmark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SpreadToBenchmark *arg1 = (FIX::SpreadToBenchmark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SpreadToBenchmark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SpreadToBenchmark, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpreadToBenchmark" "', argument " "1"" of type '" "FIX::SpreadToBenchmark *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SpreadToBenchmark * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SpreadToBenchmark_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SpreadToBenchmark, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CommType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CommType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CommType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CommType *)new FIX::CommType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CommType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CommType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CommType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CommType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CommType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CommType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CommType *)new FIX::CommType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CommType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CommType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CommType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CommType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CommType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CommType::CommType()\n"
    "    FIX::CommType::CommType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CommType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CommType *arg1 = (FIX::CommType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CommType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CommType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CommType" "', argument " "1"" of type '" "FIX::CommType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CommType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CommType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CommType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RegistRejReasonCode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistRejReasonCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RegistRejReasonCode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistRejReasonCode *)new FIX::RegistRejReasonCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistRejReasonCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistRejReasonCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RegistRejReasonCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RegistRejReasonCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegistRejReasonCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegistRejReasonCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistRejReasonCode *)new FIX::RegistRejReasonCode((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistRejReasonCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistRejReasonCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RegistRejReasonCode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistRejReasonCode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RegistRejReasonCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RegistRejReasonCode::RegistRejReasonCode()\n"
    "    FIX::RegistRejReasonCode::RegistRejReasonCode(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RegistRejReasonCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistRejReasonCode *arg1 = (FIX::RegistRejReasonCode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RegistRejReasonCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RegistRejReasonCode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegistRejReasonCode" "', argument " "1"" of type '" "FIX::RegistRejReasonCode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RegistRejReasonCode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RegistRejReasonCode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RegistRejReasonCode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SideTimeInForce__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideTimeInForce *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideTimeInForce")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTimeInForce *)new FIX::SideTimeInForce();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTimeInForce, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTimeInForce__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideTimeInForce *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideTimeInForce",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SideTimeInForce" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTimeInForce *)new FIX::SideTimeInForce(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTimeInForce, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTimeInForce__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideTimeInForce *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideTimeInForce",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideTimeInForce" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideTimeInForce" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTimeInForce *)new FIX::SideTimeInForce((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTimeInForce, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTimeInForce__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::SideTimeInForce *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_SideTimeInForce",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideTimeInForce" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideTimeInForce" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SideTimeInForce" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTimeInForce *)new FIX::SideTimeInForce((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTimeInForce, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTimeInForce(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideTimeInForce__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideTimeInForce__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_SideTimeInForce__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SideTimeInForce__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideTimeInForce'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideTimeInForce::SideTimeInForce()\n"
    "    FIX::SideTimeInForce::SideTimeInForce(bool)\n"
    "    FIX::SideTimeInForce::SideTimeInForce(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::SideTimeInForce::SideTimeInForce(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideTimeInForce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideTimeInForce *arg1 = (FIX::SideTimeInForce *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideTimeInForce",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideTimeInForce, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideTimeInForce" "', argument " "1"" of type '" "FIX::SideTimeInForce *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideTimeInForce * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SideTimeInForce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SideTimeInForce, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TrdRegTimestamp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdRegTimestamp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TrdRegTimestamp")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdRegTimestamp *)new FIX::TrdRegTimestamp();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdRegTimestamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestamp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TrdRegTimestamp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TrdRegTimestamp",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TrdRegTimestamp" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdRegTimestamp *)new FIX::TrdRegTimestamp(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdRegTimestamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestamp__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TrdRegTimestamp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TrdRegTimestamp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdRegTimestamp *)new FIX::TrdRegTimestamp((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdRegTimestamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestamp__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::TrdRegTimestamp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TrdRegTimestamp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TrdRegTimestamp" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TrdRegTimestamp" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdRegTimestamp *)new FIX::TrdRegTimestamp((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdRegTimestamp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestamp(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TrdRegTimestamp__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdRegTimestamp__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_TrdRegTimestamp__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TrdRegTimestamp__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TrdRegTimestamp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TrdRegTimestamp::TrdRegTimestamp()\n"
    "    FIX::TrdRegTimestamp::TrdRegTimestamp(bool)\n"
    "    FIX::TrdRegTimestamp::TrdRegTimestamp(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::TrdRegTimestamp::TrdRegTimestamp(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TrdRegTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdRegTimestamp *arg1 = (FIX::TrdRegTimestamp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TrdRegTimestamp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TrdRegTimestamp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrdRegTimestamp" "', argument " "1"" of type '" "FIX::TrdRegTimestamp *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TrdRegTimestamp * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TrdRegTimestamp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TrdRegTimestamp, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FinancialStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FinancialStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FinancialStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FinancialStatus *)new FIX::FinancialStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FinancialStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FinancialStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FinancialStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FinancialStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MULTIPLECHARVALUE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FinancialStatus" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FinancialStatus" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLECHARVALUE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FinancialStatus *)new FIX::FinancialStatus((FIX::MULTIPLECHARVALUE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FinancialStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FinancialStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FinancialStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MULTIPLECHARVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FinancialStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FinancialStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FinancialStatus::FinancialStatus()\n"
    "    FIX::FinancialStatus::FinancialStatus(FIX::MULTIPLECHARVALUE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FinancialStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FinancialStatus *arg1 = (FIX::FinancialStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FinancialStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FinancialStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FinancialStatus" "', argument " "1"" of type '" "FIX::FinancialStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FinancialStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FinancialStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FinancialStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoTrades__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTrades *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoTrades")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTrades *)new FIX::NoTrades();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTrades, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTrades__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoTrades *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoTrades",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoTrades" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoTrades" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTrades *)new FIX::NoTrades((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTrades, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTrades(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoTrades__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTrades__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoTrades'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoTrades::NoTrades()\n"
    "    FIX::NoTrades::NoTrades(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoTrades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTrades *arg1 = (FIX::NoTrades *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoTrades",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoTrades, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoTrades" "', argument " "1"" of type '" "FIX::NoTrades *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoTrades * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoTrades_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoTrades, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LastFragment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastFragment *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastFragment")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastFragment *)new FIX::LastFragment();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastFragment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastFragment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastFragment *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastFragment",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastFragment" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastFragment" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastFragment *)new FIX::LastFragment((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastFragment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastFragment(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastFragment__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastFragment__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastFragment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastFragment::LastFragment()\n"
    "    FIX::LastFragment::LastFragment(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastFragment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastFragment *arg1 = (FIX::LastFragment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastFragment",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastFragment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastFragment" "', argument " "1"" of type '" "FIX::LastFragment *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastFragment * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LastFragment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LastFragment, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PartySubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PartySubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartySubID *)new FIX::PartySubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartySubID *)new FIX::PartySubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PartySubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartySubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PartySubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PartySubID::PartySubID()\n"
    "    FIX::PartySubID::PartySubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PartySubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartySubID *arg1 = (FIX::PartySubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PartySubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PartySubID" "', argument " "1"" of type '" "FIX::PartySubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PartySubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PartySubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PartySubID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocQty *)new FIX::AllocQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocQty *)new FIX::AllocQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocQty::AllocQty()\n"
    "    FIX::AllocQty::AllocQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocQty *arg1 = (FIX::AllocQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocQty" "', argument " "1"" of type '" "FIX::AllocQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NotifyBrokerOfCredit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NotifyBrokerOfCredit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NotifyBrokerOfCredit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NotifyBrokerOfCredit *)new FIX::NotifyBrokerOfCredit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NotifyBrokerOfCredit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotifyBrokerOfCredit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NotifyBrokerOfCredit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NotifyBrokerOfCredit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NotifyBrokerOfCredit" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NotifyBrokerOfCredit" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NotifyBrokerOfCredit *)new FIX::NotifyBrokerOfCredit((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NotifyBrokerOfCredit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotifyBrokerOfCredit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NotifyBrokerOfCredit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NotifyBrokerOfCredit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NotifyBrokerOfCredit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NotifyBrokerOfCredit::NotifyBrokerOfCredit()\n"
    "    FIX::NotifyBrokerOfCredit::NotifyBrokerOfCredit(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NotifyBrokerOfCredit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NotifyBrokerOfCredit *arg1 = (FIX::NotifyBrokerOfCredit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NotifyBrokerOfCredit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NotifyBrokerOfCredit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NotifyBrokerOfCredit" "', argument " "1"" of type '" "FIX::NotifyBrokerOfCredit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NotifyBrokerOfCredit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NotifyBrokerOfCredit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NotifyBrokerOfCredit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestampType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideTrdRegTimestampType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideTrdRegTimestampType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTrdRegTimestampType *)new FIX::SideTrdRegTimestampType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTrdRegTimestampType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestampType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideTrdRegTimestampType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideTrdRegTimestampType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideTrdRegTimestampType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideTrdRegTimestampType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideTrdRegTimestampType *)new FIX::SideTrdRegTimestampType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideTrdRegTimestampType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideTrdRegTimestampType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideTrdRegTimestampType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideTrdRegTimestampType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideTrdRegTimestampType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideTrdRegTimestampType::SideTrdRegTimestampType()\n"
    "    FIX::SideTrdRegTimestampType::SideTrdRegTimestampType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideTrdRegTimestampType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideTrdRegTimestampType *arg1 = (FIX::SideTrdRegTimestampType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideTrdRegTimestampType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideTrdRegTimestampType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideTrdRegTimestampType" "', argument " "1"" of type '" "FIX::SideTrdRegTimestampType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideTrdRegTimestampType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SideTrdRegTimestampType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SideTrdRegTimestampType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AgreementDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AgreementDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AgreementDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AgreementDate *)new FIX::AgreementDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AgreementDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AgreementDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AgreementDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AgreementDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AgreementDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AgreementDate *)new FIX::AgreementDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AgreementDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AgreementDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AgreementDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AgreementDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AgreementDate::AgreementDate()\n"
    "    FIX::AgreementDate::AgreementDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AgreementDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AgreementDate *arg1 = (FIX::AgreementDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AgreementDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AgreementDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AgreementDate" "', argument " "1"" of type '" "FIX::AgreementDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AgreementDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AgreementDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AgreementDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PartySubIDType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PartySubIDType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartySubIDType *)new FIX::PartySubIDType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartySubIDType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PartySubIDType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PartySubIDType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartySubIDType *)new FIX::PartySubIDType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartySubIDType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartySubIDType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PartySubIDType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartySubIDType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PartySubIDType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PartySubIDType::PartySubIDType()\n"
    "    FIX::PartySubIDType::PartySubIDType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PartySubIDType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartySubIDType *arg1 = (FIX::PartySubIDType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PartySubIDType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PartySubIDType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PartySubIDType" "', argument " "1"" of type '" "FIX::PartySubIDType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PartySubIDType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PartySubIDType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PartySubIDType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TotalNetValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalNetValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotalNetValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalNetValue *)new FIX::TotalNetValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalNetValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNetValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotalNetValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotalNetValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotalNetValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotalNetValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotalNetValue *)new FIX::TotalNetValue((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotalNetValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotalNetValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotalNetValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotalNetValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotalNetValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotalNetValue::TotalNetValue()\n"
    "    FIX::TotalNetValue::TotalNetValue(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotalNetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotalNetValue *arg1 = (FIX::TotalNetValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotalNetValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotalNetValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotalNetValue" "', argument " "1"" of type '" "FIX::TotalNetValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotalNetValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TotalNetValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TotalNetValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocNoOrdersType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocNoOrdersType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocNoOrdersType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocNoOrdersType *)new FIX::AllocNoOrdersType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocNoOrdersType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocNoOrdersType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocNoOrdersType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocNoOrdersType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocNoOrdersType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocNoOrdersType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocNoOrdersType *)new FIX::AllocNoOrdersType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocNoOrdersType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocNoOrdersType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocNoOrdersType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocNoOrdersType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocNoOrdersType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocNoOrdersType::AllocNoOrdersType()\n"
    "    FIX::AllocNoOrdersType::AllocNoOrdersType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocNoOrdersType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocNoOrdersType *arg1 = (FIX::AllocNoOrdersType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocNoOrdersType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocNoOrdersType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocNoOrdersType" "', argument " "1"" of type '" "FIX::AllocNoOrdersType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocNoOrdersType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocNoOrdersType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocNoOrdersType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocLinkID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocLinkID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocLinkID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocLinkID *)new FIX::AllocLinkID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocLinkID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocLinkID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocLinkID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocLinkID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocLinkID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocLinkID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocLinkID *)new FIX::AllocLinkID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocLinkID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocLinkID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocLinkID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocLinkID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocLinkID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocLinkID::AllocLinkID()\n"
    "    FIX::AllocLinkID::AllocLinkID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocLinkID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocLinkID *arg1 = (FIX::AllocLinkID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocLinkID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocLinkID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocLinkID" "', argument " "1"" of type '" "FIX::AllocLinkID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocLinkID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocLinkID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocLinkID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RoundingModulus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RoundingModulus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RoundingModulus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RoundingModulus *)new FIX::RoundingModulus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RoundingModulus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoundingModulus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RoundingModulus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RoundingModulus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RoundingModulus" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RoundingModulus" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RoundingModulus *)new FIX::RoundingModulus((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RoundingModulus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RoundingModulus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RoundingModulus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RoundingModulus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RoundingModulus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RoundingModulus::RoundingModulus()\n"
    "    FIX::RoundingModulus::RoundingModulus(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RoundingModulus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RoundingModulus *arg1 = (FIX::RoundingModulus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RoundingModulus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RoundingModulus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RoundingModulus" "', argument " "1"" of type '" "FIX::RoundingModulus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RoundingModulus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RoundingModulus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RoundingModulus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OnBehalfOfCompID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OnBehalfOfCompID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OnBehalfOfCompID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OnBehalfOfCompID *)new FIX::OnBehalfOfCompID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OnBehalfOfCompID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfCompID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OnBehalfOfCompID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OnBehalfOfCompID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OnBehalfOfCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OnBehalfOfCompID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OnBehalfOfCompID *)new FIX::OnBehalfOfCompID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OnBehalfOfCompID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfCompID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OnBehalfOfCompID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OnBehalfOfCompID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OnBehalfOfCompID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OnBehalfOfCompID::OnBehalfOfCompID()\n"
    "    FIX::OnBehalfOfCompID::OnBehalfOfCompID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OnBehalfOfCompID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OnBehalfOfCompID *arg1 = (FIX::OnBehalfOfCompID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OnBehalfOfCompID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OnBehalfOfCompID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OnBehalfOfCompID" "', argument " "1"" of type '" "FIX::OnBehalfOfCompID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OnBehalfOfCompID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OnBehalfOfCompID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OnBehalfOfCompID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSecurityID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecurityID *)new FIX::UnderlyingSecurityID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecurityID *)new FIX::UnderlyingSecurityID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSecurityID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecurityID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSecurityID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSecurityID::UnderlyingSecurityID()\n"
    "    FIX::UnderlyingSecurityID::UnderlyingSecurityID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSecurityID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecurityID *arg1 = (FIX::UnderlyingSecurityID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSecurityID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSecurityID" "', argument " "1"" of type '" "FIX::UnderlyingSecurityID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSecurityID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingSecurityID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingSecurityID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlObligMsgID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlObligMsgID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlObligMsgID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlObligMsgID *)new FIX::SettlObligMsgID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlObligMsgID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligMsgID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlObligMsgID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlObligMsgID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlObligMsgID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlObligMsgID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlObligMsgID *)new FIX::SettlObligMsgID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlObligMsgID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligMsgID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlObligMsgID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlObligMsgID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlObligMsgID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlObligMsgID::SettlObligMsgID()\n"
    "    FIX::SettlObligMsgID::SettlObligMsgID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlObligMsgID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlObligMsgID *arg1 = (FIX::SettlObligMsgID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlObligMsgID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlObligMsgID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlObligMsgID" "', argument " "1"" of type '" "FIX::SettlObligMsgID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlObligMsgID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlObligMsgID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlObligMsgID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PositionLimit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PositionLimit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PositionLimit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PositionLimit *)new FIX::PositionLimit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PositionLimit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PositionLimit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PositionLimit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PositionLimit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PositionLimit *)new FIX::PositionLimit((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PositionLimit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PositionLimit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PositionLimit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PositionLimit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PositionLimit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PositionLimit::PositionLimit()\n"
    "    FIX::PositionLimit::PositionLimit(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PositionLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PositionLimit *arg1 = (FIX::PositionLimit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PositionLimit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PositionLimit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PositionLimit" "', argument " "1"" of type '" "FIX::PositionLimit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PositionLimit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PositionLimit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PositionLimit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SharedCommission__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SharedCommission *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SharedCommission")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SharedCommission *)new FIX::SharedCommission();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SharedCommission, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SharedCommission__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SharedCommission *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SharedCommission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SharedCommission" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SharedCommission" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SharedCommission *)new FIX::SharedCommission((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SharedCommission, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SharedCommission(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SharedCommission__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SharedCommission__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SharedCommission'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SharedCommission::SharedCommission()\n"
    "    FIX::SharedCommission::SharedCommission(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SharedCommission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SharedCommission *arg1 = (FIX::SharedCommission *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SharedCommission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SharedCommission, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SharedCommission" "', argument " "1"" of type '" "FIX::SharedCommission *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SharedCommission * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SharedCommission_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SharedCommission, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessPct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllowableOneSidednessPct *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllowableOneSidednessPct")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllowableOneSidednessPct *)new FIX::AllowableOneSidednessPct();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllowableOneSidednessPct, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessPct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllowableOneSidednessPct *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllowableOneSidednessPct",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllowableOneSidednessPct" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllowableOneSidednessPct" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllowableOneSidednessPct *)new FIX::AllowableOneSidednessPct((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllowableOneSidednessPct, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllowableOneSidednessPct(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllowableOneSidednessPct__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllowableOneSidednessPct__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllowableOneSidednessPct'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllowableOneSidednessPct::AllowableOneSidednessPct()\n"
    "    FIX::AllowableOneSidednessPct::AllowableOneSidednessPct(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllowableOneSidednessPct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllowableOneSidednessPct *arg1 = (FIX::AllowableOneSidednessPct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllowableOneSidednessPct",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllowableOneSidednessPct, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllowableOneSidednessPct" "', argument " "1"" of type '" "FIX::AllowableOneSidednessPct *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllowableOneSidednessPct * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllowableOneSidednessPct_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllowableOneSidednessPct, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocText")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocText *)new FIX::AllocText();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocText *)new FIX::AllocText((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocText__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocText__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocText::AllocText()\n"
    "    FIX::AllocText::AllocText(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocText *arg1 = (FIX::AllocText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocText" "', argument " "1"" of type '" "FIX::AllocText *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocText * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EndSeqNo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EndSeqNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EndSeqNo")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EndSeqNo *)new FIX::EndSeqNo();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EndSeqNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndSeqNo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EndSeqNo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EndSeqNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SEQNUM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EndSeqNo" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EndSeqNo" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EndSeqNo *)new FIX::EndSeqNo((FIX::SEQNUM const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EndSeqNo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndSeqNo(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EndSeqNo__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EndSeqNo__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EndSeqNo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EndSeqNo::EndSeqNo()\n"
    "    FIX::EndSeqNo::EndSeqNo(FIX::SEQNUM const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EndSeqNo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EndSeqNo *arg1 = (FIX::EndSeqNo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EndSeqNo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EndSeqNo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EndSeqNo" "', argument " "1"" of type '" "FIX::EndSeqNo *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EndSeqNo * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EndSeqNo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EndSeqNo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoPartyIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoPartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoPartyIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPartyIDs *)new FIX::NoPartyIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoPartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoPartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoPartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoPartyIDs *)new FIX::NoPartyIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoPartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoPartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoPartyIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoPartyIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoPartyIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoPartyIDs::NoPartyIDs()\n"
    "    FIX::NoPartyIDs::NoPartyIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoPartyIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoPartyIDs *arg1 = (FIX::NoPartyIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoPartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoPartyIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoPartyIDs" "', argument " "1"" of type '" "FIX::NoPartyIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoPartyIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoPartyIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoPartyIDs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoContraBrokers__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoContraBrokers *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoContraBrokers")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoContraBrokers *)new FIX::NoContraBrokers();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoContraBrokers, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoContraBrokers__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoContraBrokers *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoContraBrokers",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoContraBrokers" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoContraBrokers" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoContraBrokers *)new FIX::NoContraBrokers((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoContraBrokers, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoContraBrokers(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoContraBrokers__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoContraBrokers__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoContraBrokers'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoContraBrokers::NoContraBrokers()\n"
    "    FIX::NoContraBrokers::NoContraBrokers(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoContraBrokers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoContraBrokers *arg1 = (FIX::NoContraBrokers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoContraBrokers",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoContraBrokers, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoContraBrokers" "', argument " "1"" of type '" "FIX::NoContraBrokers *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoContraBrokers * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoContraBrokers_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoContraBrokers, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocLinkType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocLinkType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocLinkType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocLinkType *)new FIX::AllocLinkType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocLinkType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocLinkType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocLinkType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocLinkType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocLinkType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocLinkType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocLinkType *)new FIX::AllocLinkType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocLinkType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocLinkType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocLinkType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocLinkType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocLinkType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocLinkType::AllocLinkType()\n"
    "    FIX::AllocLinkType::AllocLinkType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocLinkType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocLinkType *arg1 = (FIX::AllocLinkType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocLinkType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocLinkType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocLinkType" "', argument " "1"" of type '" "FIX::AllocLinkType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocLinkType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocLinkType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocLinkType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingAllocationPercent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingAllocationPercent *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingAllocationPercent")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingAllocationPercent *)new FIX::UnderlyingAllocationPercent();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingAllocationPercent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingAllocationPercent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingAllocationPercent *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingAllocationPercent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingAllocationPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingAllocationPercent" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingAllocationPercent *)new FIX::UnderlyingAllocationPercent((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingAllocationPercent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingAllocationPercent(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingAllocationPercent__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingAllocationPercent__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingAllocationPercent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingAllocationPercent::UnderlyingAllocationPercent()\n"
    "    FIX::UnderlyingAllocationPercent::UnderlyingAllocationPercent(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingAllocationPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingAllocationPercent *arg1 = (FIX::UnderlyingAllocationPercent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingAllocationPercent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingAllocationPercent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingAllocationPercent" "', argument " "1"" of type '" "FIX::UnderlyingAllocationPercent *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingAllocationPercent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingAllocationPercent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingAllocationPercent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocAccruedInterestAmt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocAccruedInterestAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocAccruedInterestAmt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocAccruedInterestAmt *)new FIX::AllocAccruedInterestAmt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocAccruedInterestAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAccruedInterestAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocAccruedInterestAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocAccruedInterestAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocAccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocAccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocAccruedInterestAmt *)new FIX::AllocAccruedInterestAmt((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocAccruedInterestAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAccruedInterestAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocAccruedInterestAmt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocAccruedInterestAmt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocAccruedInterestAmt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocAccruedInterestAmt::AllocAccruedInterestAmt()\n"
    "    FIX::AllocAccruedInterestAmt::AllocAccruedInterestAmt(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocAccruedInterestAmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocAccruedInterestAmt *arg1 = (FIX::AllocAccruedInterestAmt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocAccruedInterestAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocAccruedInterestAmt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocAccruedInterestAmt" "', argument " "1"" of type '" "FIX::AllocAccruedInterestAmt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocAccruedInterestAmt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocAccruedInterestAmt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocAccruedInterestAmt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncodedSecurityListDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedSecurityListDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedSecurityListDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSecurityListDesc *)new FIX::EncodedSecurityListDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSecurityListDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityListDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedSecurityListDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedSecurityListDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedSecurityListDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedSecurityListDesc" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSecurityListDesc *)new FIX::EncodedSecurityListDesc((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSecurityListDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityListDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedSecurityListDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedSecurityListDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedSecurityListDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedSecurityListDesc::EncodedSecurityListDesc()\n"
    "    FIX::EncodedSecurityListDesc::EncodedSecurityListDesc(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedSecurityListDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedSecurityListDesc *arg1 = (FIX::EncodedSecurityListDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedSecurityListDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedSecurityListDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedSecurityListDesc" "', argument " "1"" of type '" "FIX::EncodedSecurityListDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedSecurityListDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncodedSecurityListDesc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedSecurityListDesc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncryptedPasswordLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncryptedPasswordLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncryptedPasswordLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncryptedPasswordLen *)new FIX::EncryptedPasswordLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncryptedPasswordLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedPasswordLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncryptedPasswordLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncryptedPasswordLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncryptedPasswordLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncryptedPasswordLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncryptedPasswordLen *)new FIX::EncryptedPasswordLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncryptedPasswordLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedPasswordLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncryptedPasswordLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncryptedPasswordLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncryptedPasswordLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncryptedPasswordLen::EncryptedPasswordLen()\n"
    "    FIX::EncryptedPasswordLen::EncryptedPasswordLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncryptedPasswordLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncryptedPasswordLen *arg1 = (FIX::EncryptedPasswordLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncryptedPasswordLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncryptedPasswordLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncryptedPasswordLen" "', argument " "1"" of type '" "FIX::EncryptedPasswordLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncryptedPasswordLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncryptedPasswordLen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncryptedPasswordLen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegDividendYield__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegDividendYield *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegDividendYield")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegDividendYield *)new FIX::LegDividendYield();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegDividendYield, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegDividendYield__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegDividendYield *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegDividendYield",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegDividendYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegDividendYield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegDividendYield *)new FIX::LegDividendYield((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegDividendYield, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegDividendYield(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegDividendYield__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegDividendYield__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegDividendYield'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegDividendYield::LegDividendYield()\n"
    "    FIX::LegDividendYield::LegDividendYield(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegDividendYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegDividendYield *arg1 = (FIX::LegDividendYield *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegDividendYield",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegDividendYield, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegDividendYield" "', argument " "1"" of type '" "FIX::LegDividendYield *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegDividendYield * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegDividendYield_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegDividendYield, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RefreshIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefreshIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefreshIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefreshIndicator *)new FIX::RefreshIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefreshIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefreshIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefreshIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefreshIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefreshIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefreshIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefreshIndicator *)new FIX::RefreshIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefreshIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefreshIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefreshIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefreshIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefreshIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefreshIndicator::RefreshIndicator()\n"
    "    FIX::RefreshIndicator::RefreshIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefreshIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefreshIndicator *arg1 = (FIX::RefreshIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefreshIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefreshIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefreshIndicator" "', argument " "1"" of type '" "FIX::RefreshIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefreshIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RefreshIndicator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RefreshIndicator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SideSettlCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideSettlCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideSettlCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideSettlCurrency *)new FIX::SideSettlCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideSettlCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideSettlCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideSettlCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideSettlCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideSettlCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideSettlCurrency *)new FIX::SideSettlCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideSettlCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideSettlCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideSettlCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideSettlCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideSettlCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideSettlCurrency::SideSettlCurrency()\n"
    "    FIX::SideSettlCurrency::SideSettlCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideSettlCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideSettlCurrency *arg1 = (FIX::SideSettlCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideSettlCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideSettlCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideSettlCurrency" "', argument " "1"" of type '" "FIX::SideSettlCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideSettlCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SideSettlCurrency_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SideSettlCurrency, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSettlementType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSettlementType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSettlementType *)new FIX::UnderlyingSettlementType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSettlementType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSettlementType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSettlementType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSettlementType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSettlementType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSettlementType *)new FIX::UnderlyingSettlementType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSettlementType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSettlementType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSettlementType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSettlementType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSettlementType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSettlementType::UnderlyingSettlementType()\n"
    "    FIX::UnderlyingSettlementType::UnderlyingSettlementType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSettlementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSettlementType *arg1 = (FIX::UnderlyingSettlementType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSettlementType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSettlementType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSettlementType" "', argument " "1"" of type '" "FIX::UnderlyingSettlementType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSettlementType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingSettlementType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingSettlementType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OrderCapacityQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderCapacityQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrderCapacityQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderCapacityQty *)new FIX::OrderCapacityQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderCapacityQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderCapacityQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrderCapacityQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrderCapacityQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrderCapacityQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrderCapacityQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderCapacityQty *)new FIX::OrderCapacityQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderCapacityQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderCapacityQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrderCapacityQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderCapacityQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrderCapacityQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrderCapacityQty::OrderCapacityQty()\n"
    "    FIX::OrderCapacityQty::OrderCapacityQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrderCapacityQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderCapacityQty *arg1 = (FIX::OrderCapacityQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrderCapacityQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrderCapacityQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrderCapacityQty" "', argument " "1"" of type '" "FIX::OrderCapacityQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrderCapacityQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrderCapacityQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrderCapacityQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LongQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LongQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LongQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LongQty *)new FIX::LongQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LongQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LongQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LongQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LongQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LongQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LongQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LongQty *)new FIX::LongQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LongQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LongQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LongQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LongQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LongQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LongQty::LongQty()\n"
    "    FIX::LongQty::LongQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LongQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LongQty *arg1 = (FIX::LongQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LongQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LongQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LongQty" "', argument " "1"" of type '" "FIX::LongQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LongQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LongQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LongQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeSettlMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSettlMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSettlMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSettlMethod *)new FIX::DerivativeSettlMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSettlMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSettlMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSettlMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSettlMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSettlMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSettlMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSettlMethod *)new FIX::DerivativeSettlMethod((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSettlMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSettlMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSettlMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSettlMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSettlMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSettlMethod::DerivativeSettlMethod()\n"
    "    FIX::DerivativeSettlMethod::DerivativeSettlMethod(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSettlMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSettlMethod *arg1 = (FIX::DerivativeSettlMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSettlMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSettlMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSettlMethod" "', argument " "1"" of type '" "FIX::DerivativeSettlMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSettlMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeSettlMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeSettlMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TriggerTradingSessionID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerTradingSessionID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerTradingSessionID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerTradingSessionID *)new FIX::TriggerTradingSessionID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerTradingSessionID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerTradingSessionID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerTradingSessionID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerTradingSessionID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerTradingSessionID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerTradingSessionID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerTradingSessionID *)new FIX::TriggerTradingSessionID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerTradingSessionID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerTradingSessionID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerTradingSessionID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerTradingSessionID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerTradingSessionID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerTradingSessionID::TriggerTradingSessionID()\n"
    "    FIX::TriggerTradingSessionID::TriggerTradingSessionID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerTradingSessionID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerTradingSessionID *arg1 = (FIX::TriggerTradingSessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerTradingSessionID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerTradingSessionID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerTradingSessionID" "', argument " "1"" of type '" "FIX::TriggerTradingSessionID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerTradingSessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TriggerTradingSessionID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TriggerTradingSessionID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DisplayMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DisplayMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DisplayMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DisplayMethod *)new FIX::DisplayMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DisplayMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DisplayMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DisplayMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DisplayMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DisplayMethod" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DisplayMethod *)new FIX::DisplayMethod((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DisplayMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DisplayMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DisplayMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DisplayMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DisplayMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DisplayMethod::DisplayMethod()\n"
    "    FIX::DisplayMethod::DisplayMethod(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DisplayMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DisplayMethod *arg1 = (FIX::DisplayMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DisplayMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DisplayMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DisplayMethod" "', argument " "1"" of type '" "FIX::DisplayMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DisplayMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DisplayMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DisplayMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RptSeq__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RptSeq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RptSeq")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RptSeq *)new FIX::RptSeq();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RptSeq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RptSeq__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RptSeq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RptSeq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RptSeq" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RptSeq" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RptSeq *)new FIX::RptSeq((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RptSeq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RptSeq(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RptSeq__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RptSeq__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RptSeq'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RptSeq::RptSeq()\n"
    "    FIX::RptSeq::RptSeq(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RptSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RptSeq *arg1 = (FIX::RptSeq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RptSeq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RptSeq, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RptSeq" "', argument " "1"" of type '" "FIX::RptSeq *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RptSeq * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RptSeq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RptSeq, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MDEntryOriginator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryOriginator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDEntryOriginator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryOriginator *)new FIX::MDEntryOriginator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryOriginator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryOriginator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDEntryOriginator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDEntryOriginator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDEntryOriginator" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDEntryOriginator" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDEntryOriginator *)new FIX::MDEntryOriginator((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDEntryOriginator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDEntryOriginator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDEntryOriginator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDEntryOriginator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDEntryOriginator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDEntryOriginator::MDEntryOriginator()\n"
    "    FIX::MDEntryOriginator::MDEntryOriginator(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDEntryOriginator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDEntryOriginator *arg1 = (FIX::MDEntryOriginator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDEntryOriginator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDEntryOriginator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDEntryOriginator" "', argument " "1"" of type '" "FIX::MDEntryOriginator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDEntryOriginator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MDEntryOriginator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MDEntryOriginator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegInstrRegistry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegInstrRegistry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegInstrRegistry")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegInstrRegistry *)new FIX::LegInstrRegistry();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegInstrRegistry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegInstrRegistry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegInstrRegistry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegInstrRegistry",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegInstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegInstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegInstrRegistry *)new FIX::LegInstrRegistry((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegInstrRegistry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegInstrRegistry(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegInstrRegistry__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegInstrRegistry__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegInstrRegistry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegInstrRegistry::LegInstrRegistry()\n"
    "    FIX::LegInstrRegistry::LegInstrRegistry(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegInstrRegistry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegInstrRegistry *arg1 = (FIX::LegInstrRegistry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegInstrRegistry",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegInstrRegistry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegInstrRegistry" "', argument " "1"" of type '" "FIX::LegInstrRegistry *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegInstrRegistry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegInstrRegistry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegInstrRegistry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FillQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FillQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FillQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FillQty *)new FIX::FillQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FillQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FillQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FillQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FillQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FillQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FillQty *)new FIX::FillQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FillQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FillQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FillQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FillQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FillQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FillQty::FillQty()\n"
    "    FIX::FillQty::FillQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FillQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FillQty *arg1 = (FIX::FillQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FillQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FillQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FillQty" "', argument " "1"" of type '" "FIX::FillQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FillQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FillQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FillQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PegSecurityIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegSecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PegSecurityIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegSecurityIDSource *)new FIX::PegSecurityIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegSecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PegSecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PegSecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PegSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PegSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PegSecurityIDSource *)new FIX::PegSecurityIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PegSecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PegSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PegSecurityIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PegSecurityIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PegSecurityIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PegSecurityIDSource::PegSecurityIDSource()\n"
    "    FIX::PegSecurityIDSource::PegSecurityIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PegSecurityIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PegSecurityIDSource *arg1 = (FIX::PegSecurityIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PegSecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PegSecurityIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PegSecurityIDSource" "', argument " "1"" of type '" "FIX::PegSecurityIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PegSecurityIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PegSecurityIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PegSecurityIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MaturityTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaturityTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityTime *)new FIX::MaturityTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TZTIMEONLY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaturityTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaturityTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__TZTIMEONLY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaturityTime" "', argument " "1"" of type '" "FIX::TZTIMEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::TZTIMEONLY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityTime *)new FIX::MaturityTime((FIX::TZTIMEONLY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaturityTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__TZTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityTime__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaturityTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaturityTime::MaturityTime()\n"
    "    FIX::MaturityTime::MaturityTime(FIX::TZTIMEONLY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaturityTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityTime *arg1 = (FIX::MaturityTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaturityTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaturityTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaturityTime" "', argument " "1"" of type '" "FIX::MaturityTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaturityTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MaturityTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MaturityTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MDFeedType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDFeedType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDFeedType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDFeedType *)new FIX::MDFeedType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDFeedType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDFeedType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDFeedType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDFeedType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDFeedType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDFeedType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDFeedType *)new FIX::MDFeedType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDFeedType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDFeedType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDFeedType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDFeedType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDFeedType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDFeedType::MDFeedType()\n"
    "    FIX::MDFeedType::MDFeedType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDFeedType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDFeedType *arg1 = (FIX::MDFeedType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDFeedType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDFeedType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDFeedType" "', argument " "1"" of type '" "FIX::MDFeedType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDFeedType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MDFeedType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MDFeedType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CollStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollStatus *)new FIX::CollStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollStatus *)new FIX::CollStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollStatus::CollStatus()\n"
    "    FIX::CollStatus::CollStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollStatus *arg1 = (FIX::CollStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollStatus" "', argument " "1"" of type '" "FIX::CollStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CollStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CollStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingSecuritySubType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecuritySubType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSecuritySubType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecuritySubType *)new FIX::UnderlyingSecuritySubType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecuritySubType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecuritySubType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSecuritySubType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSecuritySubType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSecuritySubType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecuritySubType *)new FIX::UnderlyingSecuritySubType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecuritySubType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecuritySubType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSecuritySubType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecuritySubType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSecuritySubType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSecuritySubType::UnderlyingSecuritySubType()\n"
    "    FIX::UnderlyingSecuritySubType::UnderlyingSecuritySubType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSecuritySubType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecuritySubType *arg1 = (FIX::UnderlyingSecuritySubType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSecuritySubType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSecuritySubType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSecuritySubType" "', argument " "1"" of type '" "FIX::UnderlyingSecuritySubType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSecuritySubType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingSecuritySubType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingSecuritySubType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CstmApplVerID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CstmApplVerID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CstmApplVerID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CstmApplVerID *)new FIX::CstmApplVerID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CstmApplVerID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CstmApplVerID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CstmApplVerID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CstmApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CstmApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CstmApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CstmApplVerID *)new FIX::CstmApplVerID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CstmApplVerID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CstmApplVerID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CstmApplVerID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CstmApplVerID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CstmApplVerID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CstmApplVerID::CstmApplVerID()\n"
    "    FIX::CstmApplVerID::CstmApplVerID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CstmApplVerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CstmApplVerID *arg1 = (FIX::CstmApplVerID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CstmApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CstmApplVerID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CstmApplVerID" "', argument " "1"" of type '" "FIX::CstmApplVerID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CstmApplVerID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CstmApplVerID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CstmApplVerID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DefaultApplExtID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DefaultApplExtID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DefaultApplExtID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DefaultApplExtID *)new FIX::DefaultApplExtID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DefaultApplExtID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultApplExtID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DefaultApplExtID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DefaultApplExtID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DefaultApplExtID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultApplExtID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DefaultApplExtID *)new FIX::DefaultApplExtID((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DefaultApplExtID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultApplExtID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DefaultApplExtID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefaultApplExtID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DefaultApplExtID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DefaultApplExtID::DefaultApplExtID()\n"
    "    FIX::DefaultApplExtID::DefaultApplExtID(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DefaultApplExtID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DefaultApplExtID *arg1 = (FIX::DefaultApplExtID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DefaultApplExtID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DefaultApplExtID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultApplExtID" "', argument " "1"" of type '" "FIX::DefaultApplExtID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DefaultApplExtID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefaultApplExtID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DefaultApplExtID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoDerivativeSecurityAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDerivativeSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoDerivativeSecurityAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDerivativeSecurityAltID *)new FIX::NoDerivativeSecurityAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDerivativeSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoDerivativeSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoDerivativeSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoDerivativeSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoDerivativeSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDerivativeSecurityAltID *)new FIX::NoDerivativeSecurityAltID((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDerivativeSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoDerivativeSecurityAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDerivativeSecurityAltID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoDerivativeSecurityAltID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoDerivativeSecurityAltID::NoDerivativeSecurityAltID()\n"
    "    FIX::NoDerivativeSecurityAltID::NoDerivativeSecurityAltID(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoDerivativeSecurityAltID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDerivativeSecurityAltID *arg1 = (FIX::NoDerivativeSecurityAltID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoDerivativeSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoDerivativeSecurityAltID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoDerivativeSecurityAltID" "', argument " "1"" of type '" "FIX::NoDerivativeSecurityAltID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoDerivativeSecurityAltID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoDerivativeSecurityAltID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoDerivativeSecurityAltID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SideValueInd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideValueInd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideValueInd")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideValueInd *)new FIX::SideValueInd();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideValueInd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideValueInd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideValueInd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideValueInd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideValueInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideValueInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideValueInd *)new FIX::SideValueInd((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideValueInd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideValueInd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideValueInd__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideValueInd__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideValueInd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideValueInd::SideValueInd()\n"
    "    FIX::SideValueInd::SideValueInd(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideValueInd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideValueInd *arg1 = (FIX::SideValueInd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideValueInd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideValueInd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideValueInd" "', argument " "1"" of type '" "FIX::SideValueInd *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideValueInd * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SideValueInd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SideValueInd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncodedText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedText")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedText *)new FIX::EncodedText();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedText" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedText" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedText *)new FIX::EncodedText((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedText__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedText__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedText::EncodedText()\n"
    "    FIX::EncodedText::EncodedText(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedText *arg1 = (FIX::EncodedText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedText" "', argument " "1"" of type '" "FIX::EncodedText *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedText * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncodedText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Account__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Account *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Account")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Account *)new FIX::Account();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Account, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Account__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Account *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Account",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Account" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Account" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Account *)new FIX::Account((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Account, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Account(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Account__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Account__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Account'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Account::Account()\n"
    "    FIX::Account::Account(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Account(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Account *arg1 = (FIX::Account *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Account",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Account, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Account" "', argument " "1"" of type '" "FIX::Account *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Account * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Account_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Account, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TriggerNewPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerNewPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerNewPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerNewPrice *)new FIX::TriggerNewPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerNewPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerNewPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerNewPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerNewPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerNewPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerNewPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerNewPrice *)new FIX::TriggerNewPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerNewPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerNewPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerNewPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerNewPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerNewPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerNewPrice::TriggerNewPrice()\n"
    "    FIX::TriggerNewPrice::TriggerNewPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerNewPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerNewPrice *arg1 = (FIX::TriggerNewPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerNewPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerNewPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerNewPrice" "', argument " "1"" of type '" "FIX::TriggerNewPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerNewPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TriggerNewPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TriggerNewPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UndlyInstrumentPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UndlyInstrumentPartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UndlyInstrumentPartyRole *)new FIX::UndlyInstrumentPartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UndlyInstrumentPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UndlyInstrumentPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UndlyInstrumentPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UndlyInstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UndlyInstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UndlyInstrumentPartyRole *)new FIX::UndlyInstrumentPartyRole((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UndlyInstrumentPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UndlyInstrumentPartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UndlyInstrumentPartyRole__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UndlyInstrumentPartyRole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UndlyInstrumentPartyRole::UndlyInstrumentPartyRole()\n"
    "    FIX::UndlyInstrumentPartyRole::UndlyInstrumentPartyRole(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UndlyInstrumentPartyRole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UndlyInstrumentPartyRole *arg1 = (FIX::UndlyInstrumentPartyRole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UndlyInstrumentPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UndlyInstrumentPartyRole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UndlyInstrumentPartyRole" "', argument " "1"" of type '" "FIX::UndlyInstrumentPartyRole *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UndlyInstrumentPartyRole * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UndlyInstrumentPartyRole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UndlyInstrumentPartyRole, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MsgDirection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MsgDirection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MsgDirection")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MsgDirection *)new FIX::MsgDirection();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MsgDirection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MsgDirection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MsgDirection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MsgDirection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MsgDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MsgDirection" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MsgDirection *)new FIX::MsgDirection((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MsgDirection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MsgDirection(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MsgDirection__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MsgDirection__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MsgDirection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MsgDirection::MsgDirection()\n"
    "    FIX::MsgDirection::MsgDirection(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MsgDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MsgDirection *arg1 = (FIX::MsgDirection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MsgDirection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MsgDirection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MsgDirection" "', argument " "1"" of type '" "FIX::MsgDirection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MsgDirection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MsgDirection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MsgDirection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegMaturityDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegMaturityDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegMaturityDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegMaturityDate *)new FIX::LegMaturityDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegMaturityDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegMaturityDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegMaturityDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegMaturityDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegMaturityDate *)new FIX::LegMaturityDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegMaturityDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegMaturityDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegMaturityDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegMaturityDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegMaturityDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegMaturityDate::LegMaturityDate()\n"
    "    FIX::LegMaturityDate::LegMaturityDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegMaturityDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegMaturityDate *arg1 = (FIX::LegMaturityDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegMaturityDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegMaturityDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegMaturityDate" "', argument " "1"" of type '" "FIX::LegMaturityDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegMaturityDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegMaturityDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegMaturityDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingContractMultiplierUnit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingContractMultiplierUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingContractMultiplierUnit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingContractMultiplierUnit *)new FIX::UnderlyingContractMultiplierUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingContractMultiplierUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingContractMultiplierUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingContractMultiplierUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingContractMultiplierUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingContractMultiplierUnit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingContractMultiplierUnit *)new FIX::UnderlyingContractMultiplierUnit((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingContractMultiplierUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingContractMultiplierUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingContractMultiplierUnit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingContractMultiplierUnit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingContractMultiplierUnit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingContractMultiplierUnit::UnderlyingContractMultiplierUnit()\n"
    "    FIX::UnderlyingContractMultiplierUnit::UnderlyingContractMultiplierUnit(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingContractMultiplierUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingContractMultiplierUnit *arg1 = (FIX::UnderlyingContractMultiplierUnit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingContractMultiplierUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingContractMultiplierUnit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingContractMultiplierUnit" "', argument " "1"" of type '" "FIX::UnderlyingContractMultiplierUnit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingContractMultiplierUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingContractMultiplierUnit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingContractMultiplierUnit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_InputSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InputSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InputSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InputSource *)new FIX::InputSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InputSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InputSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InputSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InputSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InputSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InputSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InputSource *)new FIX::InputSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InputSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InputSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InputSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InputSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InputSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InputSource::InputSource()\n"
    "    FIX::InputSource::InputSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InputSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InputSource *arg1 = (FIX::InputSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InputSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InputSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputSource" "', argument " "1"" of type '" "FIX::InputSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InputSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InputSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__InputSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MDUpdateAction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDUpdateAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDUpdateAction")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDUpdateAction *)new FIX::MDUpdateAction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDUpdateAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDUpdateAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDUpdateAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDUpdateAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDUpdateAction" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDUpdateAction *)new FIX::MDUpdateAction((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDUpdateAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDUpdateAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDUpdateAction__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDUpdateAction__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDUpdateAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDUpdateAction::MDUpdateAction()\n"
    "    FIX::MDUpdateAction::MDUpdateAction(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDUpdateAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDUpdateAction *arg1 = (FIX::MDUpdateAction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDUpdateAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDUpdateAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDUpdateAction" "', argument " "1"" of type '" "FIX::MDUpdateAction *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDUpdateAction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MDUpdateAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MDUpdateAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MatchStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MatchStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MatchStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MatchStatus *)new FIX::MatchStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MatchStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MatchStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MatchStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatchStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatchStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MatchStatus *)new FIX::MatchStatus((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MatchStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MatchStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MatchStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MatchStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MatchStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MatchStatus::MatchStatus()\n"
    "    FIX::MatchStatus::MatchStatus(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MatchStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MatchStatus *arg1 = (FIX::MatchStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MatchStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MatchStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MatchStatus" "', argument " "1"" of type '" "FIX::MatchStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MatchStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MatchStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MatchStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RateSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RateSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RateSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RateSource *)new FIX::RateSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RateSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RateSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RateSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RateSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RateSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RateSource *)new FIX::RateSource((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RateSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RateSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RateSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RateSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RateSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RateSource::RateSource()\n"
    "    FIX::RateSource::RateSource(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RateSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RateSource *arg1 = (FIX::RateSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RateSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RateSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RateSource" "', argument " "1"" of type '" "FIX::RateSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RateSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RateSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RateSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocPositionEffect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocPositionEffect *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocPositionEffect")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocPositionEffect *)new FIX::AllocPositionEffect();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocPositionEffect, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocPositionEffect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocPositionEffect *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocPositionEffect",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocPositionEffect" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocPositionEffect" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocPositionEffect *)new FIX::AllocPositionEffect((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocPositionEffect, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocPositionEffect(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocPositionEffect__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocPositionEffect__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocPositionEffect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocPositionEffect::AllocPositionEffect()\n"
    "    FIX::AllocPositionEffect::AllocPositionEffect(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocPositionEffect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocPositionEffect *arg1 = (FIX::AllocPositionEffect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocPositionEffect",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocPositionEffect, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocPositionEffect" "', argument " "1"" of type '" "FIX::AllocPositionEffect *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocPositionEffect * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocPositionEffect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocPositionEffect, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyIDSource *)new FIX::PartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PartyIDSource *)new FIX::PartyIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PartyIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PartyIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PartyIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PartyIDSource::PartyIDSource()\n"
    "    FIX::PartyIDSource::PartyIDSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PartyIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PartyIDSource *arg1 = (FIX::PartyIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PartyIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PartyIDSource" "', argument " "1"" of type '" "FIX::PartyIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PartyIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PartyIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PartyIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingIssuer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedUnderlyingIssuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedUnderlyingIssuer")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedUnderlyingIssuer *)new FIX::EncodedUnderlyingIssuer();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedUnderlyingIssuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingIssuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedUnderlyingIssuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedUnderlyingIssuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedUnderlyingIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedUnderlyingIssuer" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedUnderlyingIssuer *)new FIX::EncodedUnderlyingIssuer((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedUnderlyingIssuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedUnderlyingIssuer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedUnderlyingIssuer__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedUnderlyingIssuer__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedUnderlyingIssuer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedUnderlyingIssuer::EncodedUnderlyingIssuer()\n"
    "    FIX::EncodedUnderlyingIssuer::EncodedUnderlyingIssuer(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedUnderlyingIssuer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedUnderlyingIssuer *arg1 = (FIX::EncodedUnderlyingIssuer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedUnderlyingIssuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedUnderlyingIssuer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedUnderlyingIssuer" "', argument " "1"" of type '" "FIX::EncodedUnderlyingIssuer *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedUnderlyingIssuer * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncodedUnderlyingIssuer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedUnderlyingIssuer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncryptedPassword__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncryptedPassword *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncryptedPassword")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncryptedPassword *)new FIX::EncryptedPassword();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncryptedPassword, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedPassword__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncryptedPassword *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncryptedPassword",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncryptedPassword" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncryptedPassword" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncryptedPassword *)new FIX::EncryptedPassword((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncryptedPassword, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedPassword(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncryptedPassword__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncryptedPassword__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncryptedPassword'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncryptedPassword::EncryptedPassword()\n"
    "    FIX::EncryptedPassword::EncryptedPassword(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncryptedPassword(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncryptedPassword *arg1 = (FIX::EncryptedPassword *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncryptedPassword",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncryptedPassword, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncryptedPassword" "', argument " "1"" of type '" "FIX::EncryptedPassword *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncryptedPassword * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncryptedPassword_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncryptedPassword, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TriggerNewQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerNewQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerNewQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerNewQty *)new FIX::TriggerNewQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerNewQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerNewQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerNewQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerNewQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerNewQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerNewQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerNewQty *)new FIX::TriggerNewQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerNewQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerNewQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerNewQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerNewQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerNewQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerNewQty::TriggerNewQty()\n"
    "    FIX::TriggerNewQty::TriggerNewQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerNewQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerNewQty *arg1 = (FIX::TriggerNewQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerNewQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerNewQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerNewQty" "', argument " "1"" of type '" "FIX::TriggerNewQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerNewQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TriggerNewQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TriggerNewQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegLastForwardPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegLastForwardPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegLastForwardPoints")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegLastForwardPoints *)new FIX::LegLastForwardPoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegLastForwardPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLastForwardPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegLastForwardPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegLastForwardPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegLastForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegLastForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegLastForwardPoints *)new FIX::LegLastForwardPoints((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegLastForwardPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLastForwardPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegLastForwardPoints__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegLastForwardPoints__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegLastForwardPoints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegLastForwardPoints::LegLastForwardPoints()\n"
    "    FIX::LegLastForwardPoints::LegLastForwardPoints(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegLastForwardPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegLastForwardPoints *arg1 = (FIX::LegLastForwardPoints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegLastForwardPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegLastForwardPoints, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegLastForwardPoints" "', argument " "1"" of type '" "FIX::LegLastForwardPoints *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegLastForwardPoints * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegLastForwardPoints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegLastForwardPoints, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TotNumTradeReports__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNumTradeReports *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotNumTradeReports")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNumTradeReports *)new FIX::TotNumTradeReports();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNumTradeReports, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNumTradeReports__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotNumTradeReports *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotNumTradeReports",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotNumTradeReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotNumTradeReports" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNumTradeReports *)new FIX::TotNumTradeReports((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNumTradeReports, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNumTradeReports(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotNumTradeReports__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNumTradeReports__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotNumTradeReports'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotNumTradeReports::TotNumTradeReports()\n"
    "    FIX::TotNumTradeReports::TotNumTradeReports(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotNumTradeReports(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNumTradeReports *arg1 = (FIX::TotNumTradeReports *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotNumTradeReports",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotNumTradeReports, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotNumTradeReports" "', argument " "1"" of type '" "FIX::TotNumTradeReports *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotNumTradeReports * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TotNumTradeReports_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TotNumTradeReports, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RefApplVerID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefApplVerID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefApplVerID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefApplVerID *)new FIX::RefApplVerID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefApplVerID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplVerID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefApplVerID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefApplVerID *)new FIX::RefApplVerID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefApplVerID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplVerID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefApplVerID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefApplVerID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefApplVerID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefApplVerID::RefApplVerID()\n"
    "    FIX::RefApplVerID::RefApplVerID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefApplVerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefApplVerID *arg1 = (FIX::RefApplVerID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefApplVerID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefApplVerID" "', argument " "1"" of type '" "FIX::RefApplVerID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefApplVerID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RefApplVerID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RefApplVerID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LastSpotRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastSpotRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastSpotRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastSpotRate *)new FIX::LastSpotRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastSpotRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastSpotRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastSpotRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastSpotRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastSpotRate" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastSpotRate" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastSpotRate *)new FIX::LastSpotRate((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastSpotRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastSpotRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastSpotRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastSpotRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastSpotRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastSpotRate::LastSpotRate()\n"
    "    FIX::LastSpotRate::LastSpotRate(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastSpotRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastSpotRate *arg1 = (FIX::LastSpotRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastSpotRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastSpotRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastSpotRate" "', argument " "1"" of type '" "FIX::LastSpotRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastSpotRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LastSpotRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LastSpotRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Price__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Price *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Price")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Price *)new FIX::Price();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Price, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Price__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Price *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Price",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Price" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Price" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Price *)new FIX::Price((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Price, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Price(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Price__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Price__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Price'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Price::Price()\n"
    "    FIX::Price::Price(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Price(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Price *arg1 = (FIX::Price *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Price",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Price, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Price" "', argument " "1"" of type '" "FIX::Price *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Price * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Price_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Price, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSecurityIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecurityIDSource *)new FIX::UnderlyingSecurityIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecurityIDSource *)new FIX::UnderlyingSecurityIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSecurityIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecurityIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSecurityIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSecurityIDSource::UnderlyingSecurityIDSource()\n"
    "    FIX::UnderlyingSecurityIDSource::UnderlyingSecurityIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSecurityIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecurityIDSource *arg1 = (FIX::UnderlyingSecurityIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSecurityIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSecurityIDSource" "', argument " "1"" of type '" "FIX::UnderlyingSecurityIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSecurityIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingSecurityIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingSecurityIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TotNoSecurityTypes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoSecurityTypes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotNoSecurityTypes")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoSecurityTypes *)new FIX::TotNoSecurityTypes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoSecurityTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoSecurityTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotNoSecurityTypes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotNoSecurityTypes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotNoSecurityTypes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotNoSecurityTypes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoSecurityTypes *)new FIX::TotNoSecurityTypes((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoSecurityTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoSecurityTypes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotNoSecurityTypes__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoSecurityTypes__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotNoSecurityTypes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotNoSecurityTypes::TotNoSecurityTypes()\n"
    "    FIX::TotNoSecurityTypes::TotNoSecurityTypes(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotNoSecurityTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoSecurityTypes *arg1 = (FIX::TotNoSecurityTypes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotNoSecurityTypes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotNoSecurityTypes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotNoSecurityTypes" "', argument " "1"" of type '" "FIX::TotNoSecurityTypes *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotNoSecurityTypes * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TotNoSecurityTypes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TotNoSecurityTypes, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ReportedPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ReportedPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ReportedPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ReportedPx *)new FIX::ReportedPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ReportedPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReportedPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ReportedPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ReportedPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ReportedPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ReportedPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ReportedPx *)new FIX::ReportedPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ReportedPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReportedPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ReportedPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ReportedPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ReportedPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ReportedPx::ReportedPx()\n"
    "    FIX::ReportedPx::ReportedPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ReportedPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ReportedPx *arg1 = (FIX::ReportedPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ReportedPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ReportedPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReportedPx" "', argument " "1"" of type '" "FIX::ReportedPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ReportedPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ReportedPx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ReportedPx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegSymbol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSymbol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSymbol")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSymbol *)new FIX::LegSymbol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSymbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSymbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSymbol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSymbol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSymbol *)new FIX::LegSymbol((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSymbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSymbol__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSymbol__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSymbol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSymbol::LegSymbol()\n"
    "    FIX::LegSymbol::LegSymbol(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSymbol *arg1 = (FIX::LegSymbol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSymbol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSymbol, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSymbol" "', argument " "1"" of type '" "FIX::LegSymbol *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegSymbol_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegSymbol, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegIssuer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegIssuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegIssuer")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegIssuer *)new FIX::LegIssuer();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegIssuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIssuer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegIssuer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegIssuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegIssuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegIssuer" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegIssuer *)new FIX::LegIssuer((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegIssuer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIssuer(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegIssuer__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegIssuer__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegIssuer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegIssuer::LegIssuer()\n"
    "    FIX::LegIssuer::LegIssuer(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegIssuer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegIssuer *arg1 = (FIX::LegIssuer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegIssuer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegIssuer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegIssuer" "', argument " "1"" of type '" "FIX::LegIssuer *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegIssuer * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegIssuer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegIssuer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RegistDetls__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistDetls *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RegistDetls")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistDetls *)new FIX::RegistDetls();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistDetls, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistDetls__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RegistDetls *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RegistDetls",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RegistDetls" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RegistDetls" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RegistDetls *)new FIX::RegistDetls((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RegistDetls, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RegistDetls(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RegistDetls__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RegistDetls__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RegistDetls'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RegistDetls::RegistDetls()\n"
    "    FIX::RegistDetls::RegistDetls(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RegistDetls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RegistDetls *arg1 = (FIX::RegistDetls *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RegistDetls",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RegistDetls, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RegistDetls" "', argument " "1"" of type '" "FIX::RegistDetls *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RegistDetls * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RegistDetls_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RegistDetls, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegSecurityID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecurityID *)new FIX::UnderlyingLegSecurityID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegSecurityID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegSecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegSecurityID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecurityID *)new FIX::UnderlyingLegSecurityID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecurityID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegSecurityID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecurityID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegSecurityID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegSecurityID::UnderlyingLegSecurityID()\n"
    "    FIX::UnderlyingLegSecurityID::UnderlyingLegSecurityID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegSecurityID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecurityID *arg1 = (FIX::UnderlyingLegSecurityID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegSecurityID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegSecurityID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegSecurityID" "', argument " "1"" of type '" "FIX::UnderlyingLegSecurityID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegSecurityID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingLegSecurityID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MinLotSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinLotSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MinLotSize")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MinLotSize *)new FIX::MinLotSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MinLotSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinLotSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MinLotSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MinLotSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MinLotSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MinLotSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MinLotSize *)new FIX::MinLotSize((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MinLotSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinLotSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MinLotSize__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinLotSize__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MinLotSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MinLotSize::MinLotSize()\n"
    "    FIX::MinLotSize::MinLotSize(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MinLotSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinLotSize *arg1 = (FIX::MinLotSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MinLotSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MinLotSize, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MinLotSize" "', argument " "1"" of type '" "FIX::MinLotSize *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MinLotSize * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MinLotSize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MinLotSize, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NumTickets__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NumTickets *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NumTickets")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NumTickets *)new FIX::NumTickets();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NumTickets, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumTickets__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NumTickets *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NumTickets",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NumTickets" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NumTickets" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NumTickets *)new FIX::NumTickets((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NumTickets, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumTickets(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NumTickets__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NumTickets__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NumTickets'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NumTickets::NumTickets()\n"
    "    FIX::NumTickets::NumTickets(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NumTickets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NumTickets *arg1 = (FIX::NumTickets *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NumTickets",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NumTickets, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NumTickets" "', argument " "1"" of type '" "FIX::NumTickets *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NumTickets * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NumTickets_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NumTickets, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegLocaleOfIssue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegLocaleOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegLocaleOfIssue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegLocaleOfIssue *)new FIX::LegLocaleOfIssue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegLocaleOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLocaleOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegLocaleOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegLocaleOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegLocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegLocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegLocaleOfIssue *)new FIX::LegLocaleOfIssue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegLocaleOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegLocaleOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegLocaleOfIssue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegLocaleOfIssue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegLocaleOfIssue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegLocaleOfIssue::LegLocaleOfIssue()\n"
    "    FIX::LegLocaleOfIssue::LegLocaleOfIssue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegLocaleOfIssue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegLocaleOfIssue *arg1 = (FIX::LegLocaleOfIssue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegLocaleOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegLocaleOfIssue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegLocaleOfIssue" "', argument " "1"" of type '" "FIX::LegLocaleOfIssue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegLocaleOfIssue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegLocaleOfIssue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegLocaleOfIssue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExchangeForPhysical__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExchangeForPhysical *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExchangeForPhysical")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExchangeForPhysical *)new FIX::ExchangeForPhysical();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExchangeForPhysical, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExchangeForPhysical__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExchangeForPhysical *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExchangeForPhysical",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExchangeForPhysical" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExchangeForPhysical" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExchangeForPhysical *)new FIX::ExchangeForPhysical((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExchangeForPhysical, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExchangeForPhysical(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExchangeForPhysical__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExchangeForPhysical__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExchangeForPhysical'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExchangeForPhysical::ExchangeForPhysical()\n"
    "    FIX::ExchangeForPhysical::ExchangeForPhysical(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExchangeForPhysical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExchangeForPhysical *arg1 = (FIX::ExchangeForPhysical *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExchangeForPhysical",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExchangeForPhysical, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExchangeForPhysical" "', argument " "1"" of type '" "FIX::ExchangeForPhysical *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExchangeForPhysical * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExchangeForPhysical_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ExchangeForPhysical, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityTradingEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityTradingEvent *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityTradingEvent")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityTradingEvent *)new FIX::SecurityTradingEvent();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityTradingEvent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityTradingEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityTradingEvent *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityTradingEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityTradingEvent" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityTradingEvent" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityTradingEvent *)new FIX::SecurityTradingEvent((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityTradingEvent, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityTradingEvent(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityTradingEvent__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityTradingEvent__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityTradingEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityTradingEvent::SecurityTradingEvent()\n"
    "    FIX::SecurityTradingEvent::SecurityTradingEvent(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityTradingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityTradingEvent *arg1 = (FIX::SecurityTradingEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityTradingEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityTradingEvent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityTradingEvent" "', argument " "1"" of type '" "FIX::SecurityTradingEvent *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityTradingEvent * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityTradingEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityTradingEvent, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MinPriceIncrementAmount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinPriceIncrementAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MinPriceIncrementAmount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MinPriceIncrementAmount *)new FIX::MinPriceIncrementAmount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MinPriceIncrementAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinPriceIncrementAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MinPriceIncrementAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MinPriceIncrementAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MinPriceIncrementAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MinPriceIncrementAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MinPriceIncrementAmount *)new FIX::MinPriceIncrementAmount((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MinPriceIncrementAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MinPriceIncrementAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MinPriceIncrementAmount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinPriceIncrementAmount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MinPriceIncrementAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MinPriceIncrementAmount::MinPriceIncrementAmount()\n"
    "    FIX::MinPriceIncrementAmount::MinPriceIncrementAmount(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MinPriceIncrementAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MinPriceIncrementAmount *arg1 = (FIX::MinPriceIncrementAmount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MinPriceIncrementAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MinPriceIncrementAmount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MinPriceIncrementAmount" "', argument " "1"" of type '" "FIX::MinPriceIncrementAmount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MinPriceIncrementAmount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MinPriceIncrementAmount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MinPriceIncrementAmount, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingPayAmount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingPayAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingPayAmount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingPayAmount *)new FIX::UnderlyingPayAmount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingPayAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPayAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingPayAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingPayAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingPayAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingPayAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingPayAmount *)new FIX::UnderlyingPayAmount((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingPayAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPayAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingPayAmount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingPayAmount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingPayAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingPayAmount::UnderlyingPayAmount()\n"
    "    FIX::UnderlyingPayAmount::UnderlyingPayAmount(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingPayAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingPayAmount *arg1 = (FIX::UnderlyingPayAmount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingPayAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingPayAmount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingPayAmount" "', argument " "1"" of type '" "FIX::UnderlyingPayAmount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingPayAmount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingPayAmount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingPayAmount, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlPartySubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlPartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlPartySubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlPartySubID *)new FIX::SettlPartySubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlPartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlPartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlPartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlPartySubID *)new FIX::SettlPartySubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlPartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlPartySubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlPartySubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlPartySubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlPartySubID::SettlPartySubID()\n"
    "    FIX::SettlPartySubID::SettlPartySubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlPartySubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlPartySubID *arg1 = (FIX::SettlPartySubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlPartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlPartySubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlPartySubID" "', argument " "1"" of type '" "FIX::SettlPartySubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlPartySubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlPartySubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlPartySubID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocNetMoney__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocNetMoney *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocNetMoney")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocNetMoney *)new FIX::AllocNetMoney();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocNetMoney, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocNetMoney__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocNetMoney *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocNetMoney",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocNetMoney" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocNetMoney" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocNetMoney *)new FIX::AllocNetMoney((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocNetMoney, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocNetMoney(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocNetMoney__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocNetMoney__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocNetMoney'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocNetMoney::AllocNetMoney()\n"
    "    FIX::AllocNetMoney::AllocNetMoney(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocNetMoney(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocNetMoney *arg1 = (FIX::AllocNetMoney *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocNetMoney",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocNetMoney, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocNetMoney" "', argument " "1"" of type '" "FIX::AllocNetMoney *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocNetMoney * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocNetMoney_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocNetMoney, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityDay__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingMaturityDay *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingMaturityDay")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingMaturityDay *)new FIX::UnderlyingMaturityDay();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingMaturityDay, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityDay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DAYOFMONTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingMaturityDay *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingMaturityDay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DAYOFMONTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingMaturityDay" "', argument " "1"" of type '" "FIX::DAYOFMONTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingMaturityDay" "', argument " "1"" of type '" "FIX::DAYOFMONTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DAYOFMONTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingMaturityDay *)new FIX::UnderlyingMaturityDay((FIX::DAYOFMONTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingMaturityDay, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityDay(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingMaturityDay__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DAYOFMONTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingMaturityDay__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingMaturityDay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingMaturityDay::UnderlyingMaturityDay()\n"
    "    FIX::UnderlyingMaturityDay::UnderlyingMaturityDay(FIX::DAYOFMONTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingMaturityDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingMaturityDay *arg1 = (FIX::UnderlyingMaturityDay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingMaturityDay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingMaturityDay, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingMaturityDay" "', argument " "1"" of type '" "FIX::UnderlyingMaturityDay *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingMaturityDay * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingMaturityDay_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingMaturityDay, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NetworkResponseID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NetworkResponseID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NetworkResponseID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NetworkResponseID *)new FIX::NetworkResponseID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NetworkResponseID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkResponseID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NetworkResponseID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NetworkResponseID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NetworkResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NetworkResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NetworkResponseID *)new FIX::NetworkResponseID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NetworkResponseID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkResponseID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NetworkResponseID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NetworkResponseID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NetworkResponseID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NetworkResponseID::NetworkResponseID()\n"
    "    FIX::NetworkResponseID::NetworkResponseID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NetworkResponseID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NetworkResponseID *arg1 = (FIX::NetworkResponseID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NetworkResponseID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NetworkResponseID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NetworkResponseID" "', argument " "1"" of type '" "FIX::NetworkResponseID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NetworkResponseID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NetworkResponseID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NetworkResponseID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NumBidders__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NumBidders *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NumBidders")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NumBidders *)new FIX::NumBidders();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NumBidders, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumBidders__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NumBidders *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NumBidders",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NumBidders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NumBidders" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NumBidders *)new FIX::NumBidders((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NumBidders, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NumBidders(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NumBidders__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NumBidders__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NumBidders'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NumBidders::NumBidders()\n"
    "    FIX::NumBidders::NumBidders(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NumBidders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NumBidders *arg1 = (FIX::NumBidders *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NumBidders",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NumBidders, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NumBidders" "', argument " "1"" of type '" "FIX::NumBidders *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NumBidders * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NumBidders_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NumBidders, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocAcctIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocAcctIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocAcctIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocAcctIDSource *)new FIX::AllocAcctIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocAcctIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAcctIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocAcctIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocAcctIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocAcctIDSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocAcctIDSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocAcctIDSource *)new FIX::AllocAcctIDSource((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocAcctIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAcctIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocAcctIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocAcctIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocAcctIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocAcctIDSource::AllocAcctIDSource()\n"
    "    FIX::AllocAcctIDSource::AllocAcctIDSource(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocAcctIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocAcctIDSource *arg1 = (FIX::AllocAcctIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocAcctIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocAcctIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocAcctIDSource" "', argument " "1"" of type '" "FIX::AllocAcctIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocAcctIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocAcctIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocAcctIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocAvgPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocAvgPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocAvgPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocAvgPx *)new FIX::AllocAvgPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocAvgPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAvgPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocAvgPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocAvgPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocAvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocAvgPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocAvgPx *)new FIX::AllocAvgPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocAvgPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocAvgPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocAvgPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocAvgPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocAvgPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocAvgPx::AllocAvgPx()\n"
    "    FIX::AllocAvgPx::AllocAvgPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocAvgPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocAvgPx *arg1 = (FIX::AllocAvgPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocAvgPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocAvgPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocAvgPx" "', argument " "1"" of type '" "FIX::AllocAvgPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocAvgPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocAvgPx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocAvgPx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentCode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecuritySettlAgentCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecuritySettlAgentCode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecuritySettlAgentCode *)new FIX::SecuritySettlAgentCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecuritySettlAgentCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecuritySettlAgentCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecuritySettlAgentCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecuritySettlAgentCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecuritySettlAgentCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecuritySettlAgentCode *)new FIX::SecuritySettlAgentCode((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecuritySettlAgentCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecuritySettlAgentCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecuritySettlAgentCode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecuritySettlAgentCode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecuritySettlAgentCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecuritySettlAgentCode::SecuritySettlAgentCode()\n"
    "    FIX::SecuritySettlAgentCode::SecuritySettlAgentCode(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecuritySettlAgentCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecuritySettlAgentCode *arg1 = (FIX::SecuritySettlAgentCode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecuritySettlAgentCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecuritySettlAgentCode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecuritySettlAgentCode" "', argument " "1"" of type '" "FIX::SecuritySettlAgentCode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecuritySettlAgentCode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecuritySettlAgentCode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecuritySettlAgentCode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoDistribInsts__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDistribInsts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoDistribInsts")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDistribInsts *)new FIX::NoDistribInsts();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDistribInsts, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDistribInsts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoDistribInsts *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoDistribInsts",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoDistribInsts" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoDistribInsts" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDistribInsts *)new FIX::NoDistribInsts((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDistribInsts, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDistribInsts(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoDistribInsts__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDistribInsts__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoDistribInsts'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoDistribInsts::NoDistribInsts()\n"
    "    FIX::NoDistribInsts::NoDistribInsts(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoDistribInsts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDistribInsts *arg1 = (FIX::NoDistribInsts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoDistribInsts",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoDistribInsts, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoDistribInsts" "', argument " "1"" of type '" "FIX::NoDistribInsts *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoDistribInsts * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoDistribInsts_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoDistribInsts, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CustDirectedOrder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CustDirectedOrder *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CustDirectedOrder")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CustDirectedOrder *)new FIX::CustDirectedOrder();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CustDirectedOrder, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustDirectedOrder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CustDirectedOrder *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CustDirectedOrder",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustDirectedOrder" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustDirectedOrder" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CustDirectedOrder *)new FIX::CustDirectedOrder((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CustDirectedOrder, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CustDirectedOrder(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CustDirectedOrder__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CustDirectedOrder__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CustDirectedOrder'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CustDirectedOrder::CustDirectedOrder()\n"
    "    FIX::CustDirectedOrder::CustDirectedOrder(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CustDirectedOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CustDirectedOrder *arg1 = (FIX::CustDirectedOrder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CustDirectedOrder",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CustDirectedOrder, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CustDirectedOrder" "', argument " "1"" of type '" "FIX::CustDirectedOrder *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CustDirectedOrder * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CustDirectedOrder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CustDirectedOrder, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FairValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FairValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FairValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FairValue *)new FIX::FairValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FairValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FairValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FairValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FairValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FairValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FairValue" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FairValue *)new FIX::FairValue((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FairValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FairValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FairValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FairValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FairValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FairValue::FairValue()\n"
    "    FIX::FairValue::FairValue(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FairValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FairValue *arg1 = (FIX::FairValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FairValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FairValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FairValue" "', argument " "1"" of type '" "FIX::FairValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FairValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FairValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FairValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoStrikes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoStrikes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoStrikes")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoStrikes *)new FIX::NoStrikes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoStrikes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStrikes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoStrikes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoStrikes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoStrikes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoStrikes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoStrikes *)new FIX::NoStrikes((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoStrikes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStrikes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoStrikes__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoStrikes__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoStrikes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoStrikes::NoStrikes()\n"
    "    FIX::NoStrikes::NoStrikes(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoStrikes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoStrikes *arg1 = (FIX::NoStrikes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoStrikes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoStrikes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoStrikes" "', argument " "1"" of type '" "FIX::NoStrikes *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoStrikes * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoStrikes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoStrikes, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncodedSecurityListDescLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedSecurityListDescLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedSecurityListDescLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSecurityListDescLen *)new FIX::EncodedSecurityListDescLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSecurityListDescLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityListDescLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedSecurityListDescLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedSecurityListDescLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedSecurityListDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedSecurityListDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSecurityListDescLen *)new FIX::EncodedSecurityListDescLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSecurityListDescLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityListDescLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedSecurityListDescLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedSecurityListDescLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedSecurityListDescLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedSecurityListDescLen::EncodedSecurityListDescLen()\n"
    "    FIX::EncodedSecurityListDescLen::EncodedSecurityListDescLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedSecurityListDescLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedSecurityListDescLen *arg1 = (FIX::EncodedSecurityListDescLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedSecurityListDescLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedSecurityListDescLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedSecurityListDescLen" "', argument " "1"" of type '" "FIX::EncodedSecurityListDescLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedSecurityListDescLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncodedSecurityListDescLen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedSecurityListDescLen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegExerciseStyle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegExerciseStyle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegExerciseStyle")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegExerciseStyle *)new FIX::LegExerciseStyle();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegExerciseStyle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegExerciseStyle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegExerciseStyle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegExerciseStyle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegExerciseStyle *)new FIX::LegExerciseStyle((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegExerciseStyle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegExerciseStyle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegExerciseStyle__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegExerciseStyle__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegExerciseStyle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegExerciseStyle::LegExerciseStyle()\n"
    "    FIX::LegExerciseStyle::LegExerciseStyle(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegExerciseStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegExerciseStyle *arg1 = (FIX::LegExerciseStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegExerciseStyle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegExerciseStyle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegExerciseStyle" "', argument " "1"" of type '" "FIX::LegExerciseStyle *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegExerciseStyle * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegExerciseStyle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegExerciseStyle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeSymbolSfx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSymbolSfx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSymbolSfx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSymbolSfx *)new FIX::DerivativeSymbolSfx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSymbolSfx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSymbolSfx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSymbolSfx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSymbolSfx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSymbolSfx *)new FIX::DerivativeSymbolSfx((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSymbolSfx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSymbolSfx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSymbolSfx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSymbolSfx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSymbolSfx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSymbolSfx::DerivativeSymbolSfx()\n"
    "    FIX::DerivativeSymbolSfx::DerivativeSymbolSfx(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSymbolSfx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSymbolSfx *arg1 = (FIX::DerivativeSymbolSfx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSymbolSfx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSymbolSfx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSymbolSfx" "', argument " "1"" of type '" "FIX::DerivativeSymbolSfx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSymbolSfx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeSymbolSfx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeSymbolSfx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NestedInstrAttribType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NestedInstrAttribType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NestedInstrAttribType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NestedInstrAttribType *)new FIX::NestedInstrAttribType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NestedInstrAttribType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedInstrAttribType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NestedInstrAttribType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NestedInstrAttribType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NestedInstrAttribType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NestedInstrAttribType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NestedInstrAttribType *)new FIX::NestedInstrAttribType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NestedInstrAttribType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NestedInstrAttribType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NestedInstrAttribType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NestedInstrAttribType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NestedInstrAttribType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NestedInstrAttribType::NestedInstrAttribType()\n"
    "    FIX::NestedInstrAttribType::NestedInstrAttribType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NestedInstrAttribType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NestedInstrAttribType *arg1 = (FIX::NestedInstrAttribType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NestedInstrAttribType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NestedInstrAttribType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NestedInstrAttribType" "', argument " "1"" of type '" "FIX::NestedInstrAttribType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NestedInstrAttribType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NestedInstrAttribType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NestedInstrAttribType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ContraTrader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContraTrader *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ContraTrader")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContraTrader *)new FIX::ContraTrader();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContraTrader, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTrader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContraTrader *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContraTrader",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContraTrader" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContraTrader" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContraTrader *)new FIX::ContraTrader((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContraTrader, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraTrader(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ContraTrader__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContraTrader__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContraTrader'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ContraTrader::ContraTrader()\n"
    "    FIX::ContraTrader::ContraTrader(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ContraTrader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContraTrader *arg1 = (FIX::ContraTrader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContraTrader",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ContraTrader, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContraTrader" "', argument " "1"" of type '" "FIX::ContraTrader *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ContraTrader * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ContraTrader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ContraTrader, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MDSecSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDSecSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDSecSize")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDSecSize *)new FIX::MDSecSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDSecSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDSecSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDSecSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDSecSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDSecSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDSecSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDSecSize *)new FIX::MDSecSize((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDSecSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDSecSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDSecSize__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDSecSize__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDSecSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDSecSize::MDSecSize()\n"
    "    FIX::MDSecSize::MDSecSize(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDSecSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDSecSize *arg1 = (FIX::MDSecSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDSecSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDSecSize, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDSecSize" "', argument " "1"" of type '" "FIX::MDSecSize *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDSecSize * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MDSecSize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MDSecSize, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoOfSecSizes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoOfSecSizes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoOfSecSizes")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoOfSecSizes *)new FIX::NoOfSecSizes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoOfSecSizes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOfSecSizes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoOfSecSizes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoOfSecSizes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoOfSecSizes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoOfSecSizes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoOfSecSizes *)new FIX::NoOfSecSizes((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoOfSecSizes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOfSecSizes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoOfSecSizes__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoOfSecSizes__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoOfSecSizes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoOfSecSizes::NoOfSecSizes()\n"
    "    FIX::NoOfSecSizes::NoOfSecSizes(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoOfSecSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoOfSecSizes *arg1 = (FIX::NoOfSecSizes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoOfSecSizes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoOfSecSizes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoOfSecSizes" "', argument " "1"" of type '" "FIX::NoOfSecSizes *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoOfSecSizes * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoOfSecSizes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoOfSecSizes, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CollAction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollAction")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollAction *)new FIX::CollAction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollAction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollAction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollAction *)new FIX::CollAction((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollAction__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollAction__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollAction::CollAction()\n"
    "    FIX::CollAction::CollAction(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollAction *arg1 = (FIX::CollAction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollAction" "', argument " "1"" of type '" "FIX::CollAction *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollAction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CollAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CollAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingLastQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLastQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLastQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLastQty *)new FIX::UnderlyingLastQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLastQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLastQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLastQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLastQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLastQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLastQty *)new FIX::UnderlyingLastQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLastQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLastQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLastQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLastQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLastQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLastQty::UnderlyingLastQty()\n"
    "    FIX::UnderlyingLastQty::UnderlyingLastQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLastQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLastQty *arg1 = (FIX::UnderlyingLastQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLastQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLastQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLastQty" "', argument " "1"" of type '" "FIX::UnderlyingLastQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLastQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingLastQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingLastQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PossDupFlag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PossDupFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PossDupFlag")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PossDupFlag *)new FIX::PossDupFlag();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PossDupFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PossDupFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PossDupFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PossDupFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PossDupFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PossDupFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PossDupFlag *)new FIX::PossDupFlag((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PossDupFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PossDupFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PossDupFlag__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PossDupFlag__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PossDupFlag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PossDupFlag::PossDupFlag()\n"
    "    FIX::PossDupFlag::PossDupFlag(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PossDupFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PossDupFlag *arg1 = (FIX::PossDupFlag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PossDupFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PossDupFlag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PossDupFlag" "', argument " "1"" of type '" "FIX::PossDupFlag *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PossDupFlag * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PossDupFlag_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PossDupFlag, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ListStatusType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListStatusType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ListStatusType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListStatusType *)new FIX::ListStatusType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListStatusType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListStatusType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ListStatusType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ListStatusType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListStatusType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListStatusType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListStatusType *)new FIX::ListStatusType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListStatusType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListStatusType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ListStatusType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListStatusType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ListStatusType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ListStatusType::ListStatusType()\n"
    "    FIX::ListStatusType::ListStatusType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListStatusType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListStatusType *arg1 = (FIX::ListStatusType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ListStatusType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ListStatusType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListStatusType" "', argument " "1"" of type '" "FIX::ListStatusType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ListStatusType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListStatusType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ListStatusType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SideFillStationCd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideFillStationCd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SideFillStationCd")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideFillStationCd *)new FIX::SideFillStationCd();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideFillStationCd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideFillStationCd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SideFillStationCd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SideFillStationCd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SideFillStationCd" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SideFillStationCd" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SideFillStationCd *)new FIX::SideFillStationCd((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SideFillStationCd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SideFillStationCd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SideFillStationCd__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SideFillStationCd__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SideFillStationCd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SideFillStationCd::SideFillStationCd()\n"
    "    FIX::SideFillStationCd::SideFillStationCd(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SideFillStationCd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SideFillStationCd *arg1 = (FIX::SideFillStationCd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SideFillStationCd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SideFillStationCd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SideFillStationCd" "', argument " "1"" of type '" "FIX::SideFillStationCd *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SideFillStationCd * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SideFillStationCd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SideFillStationCd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StatusText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StatusText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StatusText")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StatusText *)new FIX::StatusText();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StatusText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StatusText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StatusText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StatusText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StatusText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StatusText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StatusText *)new FIX::StatusText((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StatusText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StatusText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StatusText__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StatusText__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StatusText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StatusText::StatusText()\n"
    "    FIX::StatusText::StatusText(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StatusText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StatusText *arg1 = (FIX::StatusText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StatusText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StatusText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StatusText" "', argument " "1"" of type '" "FIX::StatusText *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StatusText * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StatusText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__StatusText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BasisFeatureDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BasisFeatureDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BasisFeatureDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BasisFeatureDate *)new FIX::BasisFeatureDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BasisFeatureDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BasisFeatureDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BasisFeatureDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BasisFeatureDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BasisFeatureDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BasisFeatureDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BasisFeatureDate *)new FIX::BasisFeatureDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BasisFeatureDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BasisFeatureDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BasisFeatureDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BasisFeatureDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BasisFeatureDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BasisFeatureDate::BasisFeatureDate()\n"
    "    FIX::BasisFeatureDate::BasisFeatureDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BasisFeatureDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BasisFeatureDate *arg1 = (FIX::BasisFeatureDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BasisFeatureDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BasisFeatureDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BasisFeatureDate" "', argument " "1"" of type '" "FIX::BasisFeatureDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BasisFeatureDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BasisFeatureDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BasisFeatureDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_XmlDataLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::XmlDataLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_XmlDataLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::XmlDataLen *)new FIX::XmlDataLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__XmlDataLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XmlDataLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::XmlDataLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_XmlDataLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XmlDataLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XmlDataLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::XmlDataLen *)new FIX::XmlDataLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__XmlDataLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XmlDataLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_XmlDataLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_XmlDataLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_XmlDataLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::XmlDataLen::XmlDataLen()\n"
    "    FIX::XmlDataLen::XmlDataLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_XmlDataLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::XmlDataLen *arg1 = (FIX::XmlDataLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_XmlDataLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__XmlDataLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XmlDataLen" "', argument " "1"" of type '" "FIX::XmlDataLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::XmlDataLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *XmlDataLen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__XmlDataLen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingMaturityDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingMaturityDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingMaturityDate *)new FIX::UnderlyingMaturityDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingMaturityDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingMaturityDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingMaturityDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingMaturityDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingMaturityDate *)new FIX::UnderlyingMaturityDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingMaturityDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingMaturityDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingMaturityDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingMaturityDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingMaturityDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingMaturityDate::UnderlyingMaturityDate()\n"
    "    FIX::UnderlyingMaturityDate::UnderlyingMaturityDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingMaturityDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingMaturityDate *arg1 = (FIX::UnderlyingMaturityDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingMaturityDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingMaturityDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingMaturityDate" "', argument " "1"" of type '" "FIX::UnderlyingMaturityDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingMaturityDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingMaturityDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingMaturityDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_GapFillFlag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::GapFillFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_GapFillFlag")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::GapFillFlag *)new FIX::GapFillFlag();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__GapFillFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GapFillFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::GapFillFlag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_GapFillFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GapFillFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GapFillFlag" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::GapFillFlag *)new FIX::GapFillFlag((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__GapFillFlag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GapFillFlag(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_GapFillFlag__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GapFillFlag__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GapFillFlag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::GapFillFlag::GapFillFlag()\n"
    "    FIX::GapFillFlag::GapFillFlag(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GapFillFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::GapFillFlag *arg1 = (FIX::GapFillFlag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_GapFillFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__GapFillFlag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GapFillFlag" "', argument " "1"" of type '" "FIX::GapFillFlag *""'"); 
  }
  arg1 = reinterpret_cast< FIX::GapFillFlag * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GapFillFlag_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__GapFillFlag, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RefApplExtID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefApplExtID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefApplExtID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefApplExtID *)new FIX::RefApplExtID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefApplExtID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplExtID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefApplExtID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefApplExtID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefApplExtID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefApplExtID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefApplExtID *)new FIX::RefApplExtID((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefApplExtID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplExtID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefApplExtID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefApplExtID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefApplExtID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefApplExtID::RefApplExtID()\n"
    "    FIX::RefApplExtID::RefApplExtID(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefApplExtID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefApplExtID *arg1 = (FIX::RefApplExtID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefApplExtID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefApplExtID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefApplExtID" "', argument " "1"" of type '" "FIX::RefApplExtID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefApplExtID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RefApplExtID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RefApplExtID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RefApplID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefApplID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefApplID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefApplID *)new FIX::RefApplID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefApplID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefApplID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefApplID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefApplID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefApplID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefApplID *)new FIX::RefApplID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefApplID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefApplID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefApplID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefApplID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefApplID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefApplID::RefApplID()\n"
    "    FIX::RefApplID::RefApplID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefApplID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefApplID *arg1 = (FIX::RefApplID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefApplID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefApplID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefApplID" "', argument " "1"" of type '" "FIX::RefApplID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefApplID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RefApplID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RefApplID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoTradingSessionRules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTradingSessionRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoTradingSessionRules")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTradingSessionRules *)new FIX::NoTradingSessionRules();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTradingSessionRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTradingSessionRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoTradingSessionRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoTradingSessionRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoTradingSessionRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoTradingSessionRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTradingSessionRules *)new FIX::NoTradingSessionRules((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTradingSessionRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTradingSessionRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoTradingSessionRules__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTradingSessionRules__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoTradingSessionRules'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoTradingSessionRules::NoTradingSessionRules()\n"
    "    FIX::NoTradingSessionRules::NoTradingSessionRules(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoTradingSessionRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTradingSessionRules *arg1 = (FIX::NoTradingSessionRules *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoTradingSessionRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoTradingSessionRules, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoTradingSessionRules" "', argument " "1"" of type '" "FIX::NoTradingSessionRules *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoTradingSessionRules * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoTradingSessionRules_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoTradingSessionRules, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SwapPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SwapPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SwapPoints")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SwapPoints *)new FIX::SwapPoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SwapPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SwapPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SwapPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SwapPoints *)new FIX::SwapPoints((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SwapPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SwapPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SwapPoints__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SwapPoints__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SwapPoints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SwapPoints::SwapPoints()\n"
    "    FIX::SwapPoints::SwapPoints(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SwapPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SwapPoints *arg1 = (FIX::SwapPoints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SwapPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SwapPoints, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwapPoints" "', argument " "1"" of type '" "FIX::SwapPoints *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SwapPoints * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SwapPoints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SwapPoints, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TargetStrategyParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetStrategyParameters *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TargetStrategyParameters")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetStrategyParameters *)new FIX::TargetStrategyParameters();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetStrategyParameters, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetStrategyParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TargetStrategyParameters *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TargetStrategyParameters",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TargetStrategyParameters" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TargetStrategyParameters" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetStrategyParameters *)new FIX::TargetStrategyParameters((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetStrategyParameters, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetStrategyParameters(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TargetStrategyParameters__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetStrategyParameters__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TargetStrategyParameters'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TargetStrategyParameters::TargetStrategyParameters()\n"
    "    FIX::TargetStrategyParameters::TargetStrategyParameters(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TargetStrategyParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetStrategyParameters *arg1 = (FIX::TargetStrategyParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TargetStrategyParameters",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TargetStrategyParameters, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TargetStrategyParameters" "', argument " "1"" of type '" "FIX::TargetStrategyParameters *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TargetStrategyParameters * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TargetStrategyParameters_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TargetStrategyParameters, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LastForwardPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastForwardPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastForwardPoints")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastForwardPoints *)new FIX::LastForwardPoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastForwardPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastForwardPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastForwardPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastForwardPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastForwardPoints *)new FIX::LastForwardPoints((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastForwardPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastForwardPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastForwardPoints__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastForwardPoints__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastForwardPoints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastForwardPoints::LastForwardPoints()\n"
    "    FIX::LastForwardPoints::LastForwardPoints(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastForwardPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastForwardPoints *arg1 = (FIX::LastForwardPoints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastForwardPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastForwardPoints, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastForwardPoints" "', argument " "1"" of type '" "FIX::LastForwardPoints *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastForwardPoints * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LastForwardPoints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LastForwardPoints, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_YieldRedemptionDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::YieldRedemptionDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_YieldRedemptionDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::YieldRedemptionDate *)new FIX::YieldRedemptionDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__YieldRedemptionDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldRedemptionDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::YieldRedemptionDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_YieldRedemptionDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_YieldRedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_YieldRedemptionDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::YieldRedemptionDate *)new FIX::YieldRedemptionDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__YieldRedemptionDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_YieldRedemptionDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_YieldRedemptionDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_YieldRedemptionDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_YieldRedemptionDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::YieldRedemptionDate::YieldRedemptionDate()\n"
    "    FIX::YieldRedemptionDate::YieldRedemptionDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_YieldRedemptionDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::YieldRedemptionDate *arg1 = (FIX::YieldRedemptionDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_YieldRedemptionDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__YieldRedemptionDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_YieldRedemptionDate" "', argument " "1"" of type '" "FIX::YieldRedemptionDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::YieldRedemptionDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *YieldRedemptionDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__YieldRedemptionDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoSettlDetails__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSettlDetails *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoSettlDetails")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSettlDetails *)new FIX::NoSettlDetails();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSettlDetails, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlDetails__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoSettlDetails *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoSettlDetails",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoSettlDetails" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoSettlDetails" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSettlDetails *)new FIX::NoSettlDetails((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSettlDetails, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSettlDetails(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoSettlDetails__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSettlDetails__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoSettlDetails'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoSettlDetails::NoSettlDetails()\n"
    "    FIX::NoSettlDetails::NoSettlDetails(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoSettlDetails(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSettlDetails *arg1 = (FIX::NoSettlDetails *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoSettlDetails",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoSettlDetails, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoSettlDetails" "', argument " "1"" of type '" "FIX::NoSettlDetails *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoSettlDetails * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoSettlDetails_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoSettlDetails, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradeHandlingInstr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeHandlingInstr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeHandlingInstr")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeHandlingInstr *)new FIX::TradeHandlingInstr();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeHandlingInstr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeHandlingInstr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeHandlingInstr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeHandlingInstr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeHandlingInstr" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeHandlingInstr" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeHandlingInstr *)new FIX::TradeHandlingInstr((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeHandlingInstr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeHandlingInstr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeHandlingInstr__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeHandlingInstr__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeHandlingInstr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeHandlingInstr::TradeHandlingInstr()\n"
    "    FIX::TradeHandlingInstr::TradeHandlingInstr(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeHandlingInstr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeHandlingInstr *arg1 = (FIX::TradeHandlingInstr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeHandlingInstr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeHandlingInstr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeHandlingInstr" "', argument " "1"" of type '" "FIX::TradeHandlingInstr *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeHandlingInstr * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradeHandlingInstr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradeHandlingInstr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CashSettlAgentCode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashSettlAgentCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashSettlAgentCode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashSettlAgentCode *)new FIX::CashSettlAgentCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashSettlAgentCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashSettlAgentCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashSettlAgentCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashSettlAgentCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashSettlAgentCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashSettlAgentCode *)new FIX::CashSettlAgentCode((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashSettlAgentCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashSettlAgentCode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashSettlAgentCode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashSettlAgentCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashSettlAgentCode::CashSettlAgentCode()\n"
    "    FIX::CashSettlAgentCode::CashSettlAgentCode(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashSettlAgentCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashSettlAgentCode *arg1 = (FIX::CashSettlAgentCode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashSettlAgentCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashSettlAgentCode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashSettlAgentCode" "', argument " "1"" of type '" "FIX::CashSettlAgentCode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashSettlAgentCode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CashSettlAgentCode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CashSettlAgentCode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegPriceType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegPriceType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegPriceType *)new FIX::LegPriceType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegPriceType *)new FIX::LegPriceType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegPriceType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegPriceType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegPriceType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegPriceType::LegPriceType()\n"
    "    FIX::LegPriceType::LegPriceType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegPriceType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegPriceType *arg1 = (FIX::LegPriceType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegPriceType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegPriceType" "', argument " "1"" of type '" "FIX::LegPriceType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegPriceType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegPriceType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegPriceType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncodedListExecInstLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedListExecInstLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedListExecInstLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedListExecInstLen *)new FIX::EncodedListExecInstLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedListExecInstLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListExecInstLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedListExecInstLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedListExecInstLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedListExecInstLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedListExecInstLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedListExecInstLen *)new FIX::EncodedListExecInstLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedListExecInstLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListExecInstLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedListExecInstLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedListExecInstLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedListExecInstLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedListExecInstLen::EncodedListExecInstLen()\n"
    "    FIX::EncodedListExecInstLen::EncodedListExecInstLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedListExecInstLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedListExecInstLen *arg1 = (FIX::EncodedListExecInstLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedListExecInstLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedListExecInstLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedListExecInstLen" "', argument " "1"" of type '" "FIX::EncodedListExecInstLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedListExecInstLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncodedListExecInstLen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedListExecInstLen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradSesMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradSesMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesMethod *)new FIX::TradSesMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradSesMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradSesMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradSesMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradSesMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradSesMethod *)new FIX::TradSesMethod((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradSesMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradSesMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradSesMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradSesMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradSesMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradSesMethod::TradSesMethod()\n"
    "    FIX::TradSesMethod::TradSesMethod(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradSesMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradSesMethod *arg1 = (FIX::TradSesMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradSesMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradSesMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradSesMethod" "', argument " "1"" of type '" "FIX::TradSesMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradSesMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradSesMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradSesMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AgreementID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AgreementID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AgreementID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AgreementID *)new FIX::AgreementID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AgreementID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AgreementID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AgreementID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AgreementID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AgreementID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AgreementID *)new FIX::AgreementID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AgreementID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AgreementID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AgreementID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AgreementID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AgreementID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AgreementID::AgreementID()\n"
    "    FIX::AgreementID::AgreementID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AgreementID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AgreementID *arg1 = (FIX::AgreementID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AgreementID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AgreementID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AgreementID" "', argument " "1"" of type '" "FIX::AgreementID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AgreementID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AgreementID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AgreementID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CashDistribCurr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashDistribCurr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashDistribCurr")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashDistribCurr *)new FIX::CashDistribCurr();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashDistribCurr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribCurr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashDistribCurr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashDistribCurr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashDistribCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashDistribCurr" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashDistribCurr *)new FIX::CashDistribCurr((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashDistribCurr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashDistribCurr(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashDistribCurr__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashDistribCurr__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashDistribCurr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashDistribCurr::CashDistribCurr()\n"
    "    FIX::CashDistribCurr::CashDistribCurr(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashDistribCurr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashDistribCurr *arg1 = (FIX::CashDistribCurr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashDistribCurr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashDistribCurr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashDistribCurr" "', argument " "1"" of type '" "FIX::CashDistribCurr *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashDistribCurr * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CashDistribCurr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CashDistribCurr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BidPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BidPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidPx *)new FIX::BidPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BidPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BidPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BidPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidPx *)new FIX::BidPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BidPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BidPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BidPx::BidPx()\n"
    "    FIX::BidPx::BidPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BidPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidPx *arg1 = (FIX::BidPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BidPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BidPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BidPx" "', argument " "1"" of type '" "FIX::BidPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BidPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BidPx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BidPx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradeType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeType *)new FIX::TradeType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeType *)new FIX::TradeType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeType::TradeType()\n"
    "    FIX::TradeType::TradeType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeType *arg1 = (FIX::TradeType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeType" "', argument " "1"" of type '" "FIX::TradeType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradeType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradeType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncodedSecurityDescLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedSecurityDescLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedSecurityDescLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSecurityDescLen *)new FIX::EncodedSecurityDescLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSecurityDescLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityDescLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedSecurityDescLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedSecurityDescLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedSecurityDescLen *)new FIX::EncodedSecurityDescLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedSecurityDescLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedSecurityDescLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedSecurityDescLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedSecurityDescLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedSecurityDescLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedSecurityDescLen::EncodedSecurityDescLen()\n"
    "    FIX::EncodedSecurityDescLen::EncodedSecurityDescLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedSecurityDescLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedSecurityDescLen *arg1 = (FIX::EncodedSecurityDescLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedSecurityDescLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedSecurityDescLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedSecurityDescLen" "', argument " "1"" of type '" "FIX::EncodedSecurityDescLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedSecurityDescLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncodedSecurityDescLen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedSecurityDescLen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ComplexEventCondition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventCondition *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ComplexEventCondition")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventCondition *)new FIX::ComplexEventCondition();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventCondition, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventCondition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ComplexEventCondition *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ComplexEventCondition",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexEventCondition" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplexEventCondition" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventCondition *)new FIX::ComplexEventCondition((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventCondition, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventCondition(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ComplexEventCondition__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventCondition__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ComplexEventCondition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ComplexEventCondition::ComplexEventCondition()\n"
    "    FIX::ComplexEventCondition::ComplexEventCondition(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ComplexEventCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventCondition *arg1 = (FIX::ComplexEventCondition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ComplexEventCondition",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ComplexEventCondition, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComplexEventCondition" "', argument " "1"" of type '" "FIX::ComplexEventCondition *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ComplexEventCondition * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ComplexEventCondition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ComplexEventCondition, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncryptedPasswordMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncryptedPasswordMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncryptedPasswordMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncryptedPasswordMethod *)new FIX::EncryptedPasswordMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncryptedPasswordMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedPasswordMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncryptedPasswordMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncryptedPasswordMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncryptedPasswordMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncryptedPasswordMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncryptedPasswordMethod *)new FIX::EncryptedPasswordMethod((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncryptedPasswordMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncryptedPasswordMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncryptedPasswordMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncryptedPasswordMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncryptedPasswordMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncryptedPasswordMethod::EncryptedPasswordMethod()\n"
    "    FIX::EncryptedPasswordMethod::EncryptedPasswordMethod(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncryptedPasswordMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncryptedPasswordMethod *arg1 = (FIX::EncryptedPasswordMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncryptedPasswordMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncryptedPasswordMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncryptedPasswordMethod" "', argument " "1"" of type '" "FIX::EncryptedPasswordMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncryptedPasswordMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncryptedPasswordMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncryptedPasswordMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeSecurityAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSecurityAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityAltID *)new FIX::DerivativeSecurityAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityAltID *)new FIX::DerivativeSecurityAltID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSecurityAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityAltID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSecurityAltID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSecurityAltID::DerivativeSecurityAltID()\n"
    "    FIX::DerivativeSecurityAltID::DerivativeSecurityAltID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSecurityAltID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityAltID *arg1 = (FIX::DerivativeSecurityAltID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSecurityAltID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSecurityAltID" "', argument " "1"" of type '" "FIX::DerivativeSecurityAltID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSecurityAltID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeSecurityAltID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeSecurityAltID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TotNoAccQuotes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoAccQuotes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotNoAccQuotes")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoAccQuotes *)new FIX::TotNoAccQuotes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoAccQuotes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoAccQuotes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotNoAccQuotes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotNoAccQuotes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotNoAccQuotes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotNoAccQuotes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoAccQuotes *)new FIX::TotNoAccQuotes((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoAccQuotes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoAccQuotes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotNoAccQuotes__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoAccQuotes__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotNoAccQuotes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotNoAccQuotes::TotNoAccQuotes()\n"
    "    FIX::TotNoAccQuotes::TotNoAccQuotes(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotNoAccQuotes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoAccQuotes *arg1 = (FIX::TotNoAccQuotes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotNoAccQuotes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotNoAccQuotes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotNoAccQuotes" "', argument " "1"" of type '" "FIX::TotNoAccQuotes *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotNoAccQuotes * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TotNoAccQuotes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TotNoAccQuotes, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TimeBracket__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TimeBracket *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TimeBracket")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TimeBracket *)new FIX::TimeBracket();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TimeBracket, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeBracket__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TimeBracket *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TimeBracket",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimeBracket" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimeBracket" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TimeBracket *)new FIX::TimeBracket((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TimeBracket, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeBracket(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TimeBracket__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TimeBracket__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TimeBracket'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TimeBracket::TimeBracket()\n"
    "    FIX::TimeBracket::TimeBracket(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TimeBracket(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TimeBracket *arg1 = (FIX::TimeBracket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TimeBracket",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TimeBracket, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeBracket" "', argument " "1"" of type '" "FIX::TimeBracket *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TimeBracket * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TimeBracket_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TimeBracket, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoAllocs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoAllocs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoAllocs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoAllocs *)new FIX::NoAllocs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoAllocs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAllocs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoAllocs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoAllocs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoAllocs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoAllocs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoAllocs *)new FIX::NoAllocs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoAllocs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoAllocs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoAllocs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoAllocs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoAllocs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoAllocs::NoAllocs()\n"
    "    FIX::NoAllocs::NoAllocs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoAllocs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoAllocs *arg1 = (FIX::NoAllocs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoAllocs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoAllocs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoAllocs" "', argument " "1"" of type '" "FIX::NoAllocs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoAllocs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoAllocs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoAllocs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingProduct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingProduct *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingProduct")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingProduct *)new FIX::UnderlyingProduct();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingProduct, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingProduct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingProduct *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingProduct",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingProduct" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingProduct" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingProduct *)new FIX::UnderlyingProduct((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingProduct, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingProduct(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingProduct__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingProduct__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingProduct'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingProduct::UnderlyingProduct()\n"
    "    FIX::UnderlyingProduct::UnderlyingProduct(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingProduct *arg1 = (FIX::UnderlyingProduct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingProduct",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingProduct, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingProduct" "', argument " "1"" of type '" "FIX::UnderlyingProduct *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingProduct * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingProduct_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingProduct, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BenchmarkCurveName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BenchmarkCurveName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BenchmarkCurveName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BenchmarkCurveName *)new FIX::BenchmarkCurveName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BenchmarkCurveName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkCurveName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BenchmarkCurveName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BenchmarkCurveName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BenchmarkCurveName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BenchmarkCurveName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BenchmarkCurveName *)new FIX::BenchmarkCurveName((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BenchmarkCurveName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkCurveName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BenchmarkCurveName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BenchmarkCurveName__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BenchmarkCurveName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BenchmarkCurveName::BenchmarkCurveName()\n"
    "    FIX::BenchmarkCurveName::BenchmarkCurveName(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BenchmarkCurveName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BenchmarkCurveName *arg1 = (FIX::BenchmarkCurveName *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BenchmarkCurveName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BenchmarkCurveName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BenchmarkCurveName" "', argument " "1"" of type '" "FIX::BenchmarkCurveName *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BenchmarkCurveName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BenchmarkCurveName_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BenchmarkCurveName, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingSymbolSfx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSymbolSfx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSymbolSfx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSymbolSfx *)new FIX::UnderlyingSymbolSfx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSymbolSfx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSymbolSfx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSymbolSfx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSymbolSfx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSymbolSfx *)new FIX::UnderlyingSymbolSfx((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSymbolSfx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSymbolSfx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSymbolSfx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSymbolSfx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSymbolSfx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSymbolSfx::UnderlyingSymbolSfx()\n"
    "    FIX::UnderlyingSymbolSfx::UnderlyingSymbolSfx(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSymbolSfx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSymbolSfx *arg1 = (FIX::UnderlyingSymbolSfx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSymbolSfx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSymbolSfx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSymbolSfx" "', argument " "1"" of type '" "FIX::UnderlyingSymbolSfx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSymbolSfx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingSymbolSfx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingSymbolSfx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StrikePriceBoundaryPrecision__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikePriceBoundaryPrecision *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StrikePriceBoundaryPrecision")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikePriceBoundaryPrecision *)new FIX::StrikePriceBoundaryPrecision();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikePriceBoundaryPrecision, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePriceBoundaryPrecision__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrikePriceBoundaryPrecision *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrikePriceBoundaryPrecision",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrikePriceBoundaryPrecision" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrikePriceBoundaryPrecision" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrikePriceBoundaryPrecision *)new FIX::StrikePriceBoundaryPrecision((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrikePriceBoundaryPrecision, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrikePriceBoundaryPrecision(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StrikePriceBoundaryPrecision__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrikePriceBoundaryPrecision__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StrikePriceBoundaryPrecision'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StrikePriceBoundaryPrecision::StrikePriceBoundaryPrecision()\n"
    "    FIX::StrikePriceBoundaryPrecision::StrikePriceBoundaryPrecision(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StrikePriceBoundaryPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrikePriceBoundaryPrecision *arg1 = (FIX::StrikePriceBoundaryPrecision *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrikePriceBoundaryPrecision",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StrikePriceBoundaryPrecision, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrikePriceBoundaryPrecision" "', argument " "1"" of type '" "FIX::StrikePriceBoundaryPrecision *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StrikePriceBoundaryPrecision * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StrikePriceBoundaryPrecision_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__StrikePriceBoundaryPrecision, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_QuoteSetID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteSetID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteSetID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteSetID *)new FIX::QuoteSetID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteSetID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteSetID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteSetID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteSetID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteSetID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteSetID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteSetID *)new FIX::QuoteSetID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteSetID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteSetID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteSetID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteSetID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteSetID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteSetID::QuoteSetID()\n"
    "    FIX::QuoteSetID::QuoteSetID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteSetID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteSetID *arg1 = (FIX::QuoteSetID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteSetID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteSetID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteSetID" "', argument " "1"" of type '" "FIX::QuoteSetID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteSetID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteSetID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__QuoteSetID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CashMargin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashMargin *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashMargin")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashMargin *)new FIX::CashMargin();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashMargin, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashMargin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashMargin *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashMargin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashMargin" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashMargin" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashMargin *)new FIX::CashMargin((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashMargin, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashMargin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashMargin__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashMargin__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashMargin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashMargin::CashMargin()\n"
    "    FIX::CashMargin::CashMargin(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashMargin *arg1 = (FIX::CashMargin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashMargin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashMargin, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashMargin" "', argument " "1"" of type '" "FIX::CashMargin *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashMargin * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CashMargin_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CashMargin, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlObligTransType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlObligTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlObligTransType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlObligTransType *)new FIX::SettlObligTransType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlObligTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlObligTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlObligTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlObligTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlObligTransType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlObligTransType *)new FIX::SettlObligTransType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlObligTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlObligTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlObligTransType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlObligTransType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlObligTransType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlObligTransType::SettlObligTransType()\n"
    "    FIX::SettlObligTransType::SettlObligTransType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlObligTransType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlObligTransType *arg1 = (FIX::SettlObligTransType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlObligTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlObligTransType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlObligTransType" "', argument " "1"" of type '" "FIX::SettlObligTransType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlObligTransType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlObligTransType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlObligTransType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegNumber__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegNumber *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegNumber")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegNumber *)new FIX::LegNumber();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegNumber__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegNumber *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegNumber",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegNumber" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegNumber" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegNumber *)new FIX::LegNumber((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegNumber, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegNumber(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegNumber__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegNumber__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegNumber'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegNumber::LegNumber()\n"
    "    FIX::LegNumber::LegNumber(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegNumber *arg1 = (FIX::LegNumber *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegNumber",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegNumber, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegNumber" "', argument " "1"" of type '" "FIX::LegNumber *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegNumber * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegNumber_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegNumber, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DeskOrderHandlingInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeskOrderHandlingInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DeskOrderHandlingInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeskOrderHandlingInst *)new FIX::DeskOrderHandlingInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeskOrderHandlingInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskOrderHandlingInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLESTRINGVALUE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DeskOrderHandlingInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DeskOrderHandlingInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeskOrderHandlingInst" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeskOrderHandlingInst" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLESTRINGVALUE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeskOrderHandlingInst *)new FIX::DeskOrderHandlingInst((FIX::MULTIPLESTRINGVALUE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeskOrderHandlingInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskOrderHandlingInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DeskOrderHandlingInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeskOrderHandlingInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DeskOrderHandlingInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DeskOrderHandlingInst::DeskOrderHandlingInst()\n"
    "    FIX::DeskOrderHandlingInst::DeskOrderHandlingInst(FIX::MULTIPLESTRINGVALUE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DeskOrderHandlingInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeskOrderHandlingInst *arg1 = (FIX::DeskOrderHandlingInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DeskOrderHandlingInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DeskOrderHandlingInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeskOrderHandlingInst" "', argument " "1"" of type '" "FIX::DeskOrderHandlingInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DeskOrderHandlingInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DeskOrderHandlingInst_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DeskOrderHandlingInst, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlPartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlPartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlPartyIDSource *)new FIX::SettlPartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlPartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlPartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlPartyIDSource *)new FIX::SettlPartyIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlPartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlPartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlPartyIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlPartyIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlPartyIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlPartyIDSource::SettlPartyIDSource()\n"
    "    FIX::SettlPartyIDSource::SettlPartyIDSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlPartyIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlPartyIDSource *arg1 = (FIX::SettlPartyIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlPartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlPartyIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlPartyIDSource" "', argument " "1"" of type '" "FIX::SettlPartyIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlPartyIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlPartyIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlPartyIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PriorSettlPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriorSettlPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PriorSettlPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriorSettlPrice *)new FIX::PriorSettlPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriorSettlPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriorSettlPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PriorSettlPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PriorSettlPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PriorSettlPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PriorSettlPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriorSettlPrice *)new FIX::PriorSettlPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriorSettlPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriorSettlPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PriorSettlPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriorSettlPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PriorSettlPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PriorSettlPrice::PriorSettlPrice()\n"
    "    FIX::PriorSettlPrice::PriorSettlPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PriorSettlPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriorSettlPrice *arg1 = (FIX::PriorSettlPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PriorSettlPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PriorSettlPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PriorSettlPrice" "', argument " "1"" of type '" "FIX::PriorSettlPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PriorSettlPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PriorSettlPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PriorSettlPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NotAffOrigClOrdID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NotAffOrigClOrdID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NotAffOrigClOrdID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NotAffOrigClOrdID *)new FIX::NotAffOrigClOrdID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NotAffOrigClOrdID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotAffOrigClOrdID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NotAffOrigClOrdID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NotAffOrigClOrdID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NotAffOrigClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NotAffOrigClOrdID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NotAffOrigClOrdID *)new FIX::NotAffOrigClOrdID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NotAffOrigClOrdID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NotAffOrigClOrdID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NotAffOrigClOrdID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NotAffOrigClOrdID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NotAffOrigClOrdID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NotAffOrigClOrdID::NotAffOrigClOrdID()\n"
    "    FIX::NotAffOrigClOrdID::NotAffOrigClOrdID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NotAffOrigClOrdID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NotAffOrigClOrdID *arg1 = (FIX::NotAffOrigClOrdID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NotAffOrigClOrdID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NotAffOrigClOrdID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NotAffOrigClOrdID" "', argument " "1"" of type '" "FIX::NotAffOrigClOrdID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NotAffOrigClOrdID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NotAffOrigClOrdID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NotAffOrigClOrdID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradingSessionDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradingSessionDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradingSessionDesc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradingSessionDesc *)new FIX::TradingSessionDesc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradingSessionDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingSessionDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradingSessionDesc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradingSessionDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradingSessionDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradingSessionDesc" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradingSessionDesc *)new FIX::TradingSessionDesc((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradingSessionDesc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradingSessionDesc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradingSessionDesc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradingSessionDesc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradingSessionDesc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradingSessionDesc::TradingSessionDesc()\n"
    "    FIX::TradingSessionDesc::TradingSessionDesc(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradingSessionDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradingSessionDesc *arg1 = (FIX::TradingSessionDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradingSessionDesc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradingSessionDesc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradingSessionDesc" "', argument " "1"" of type '" "FIX::TradingSessionDesc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradingSessionDesc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradingSessionDesc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradingSessionDesc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeFloorPrice__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeFloorPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeFloorPrice")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeFloorPrice *)new FIX::DerivativeFloorPrice();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeFloorPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeFloorPrice__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeFloorPrice *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeFloorPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeFloorPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeFloorPrice" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeFloorPrice *)new FIX::DerivativeFloorPrice((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeFloorPrice, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeFloorPrice(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeFloorPrice__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeFloorPrice__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeFloorPrice'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeFloorPrice::DerivativeFloorPrice()\n"
    "    FIX::DerivativeFloorPrice::DerivativeFloorPrice(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeFloorPrice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeFloorPrice *arg1 = (FIX::DerivativeFloorPrice *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeFloorPrice",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeFloorPrice, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeFloorPrice" "', argument " "1"" of type '" "FIX::DerivativeFloorPrice *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeFloorPrice * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeFloorPrice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeFloorPrice, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeSymbol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSymbol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSymbol")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSymbol *)new FIX::DerivativeSymbol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSymbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSymbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSymbol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSymbol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSymbol *)new FIX::DerivativeSymbol((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSymbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSymbol__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSymbol__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSymbol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSymbol::DerivativeSymbol()\n"
    "    FIX::DerivativeSymbol::DerivativeSymbol(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSymbol *arg1 = (FIX::DerivativeSymbol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSymbol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSymbol, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSymbol" "', argument " "1"" of type '" "FIX::DerivativeSymbol *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeSymbol_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeSymbol, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RiskFreeRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskFreeRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RiskFreeRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskFreeRate *)new FIX::RiskFreeRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskFreeRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskFreeRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RiskFreeRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RiskFreeRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RiskFreeRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RiskFreeRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RiskFreeRate *)new FIX::RiskFreeRate((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RiskFreeRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RiskFreeRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RiskFreeRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RiskFreeRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RiskFreeRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RiskFreeRate::RiskFreeRate()\n"
    "    FIX::RiskFreeRate::RiskFreeRate(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RiskFreeRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RiskFreeRate *arg1 = (FIX::RiskFreeRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RiskFreeRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RiskFreeRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RiskFreeRate" "', argument " "1"" of type '" "FIX::RiskFreeRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RiskFreeRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RiskFreeRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RiskFreeRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PosTransType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PosTransType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosTransType *)new FIX::PosTransType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosTransType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PosTransType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PosTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PosTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PosTransType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosTransType *)new FIX::PosTransType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosTransType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosTransType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PosTransType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosTransType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PosTransType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PosTransType::PosTransType()\n"
    "    FIX::PosTransType::PosTransType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PosTransType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosTransType *arg1 = (FIX::PosTransType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PosTransType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PosTransType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PosTransType" "', argument " "1"" of type '" "FIX::PosTransType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PosTransType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PosTransType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PosTransType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MsgSeqNum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MsgSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MsgSeqNum")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MsgSeqNum *)new FIX::MsgSeqNum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MsgSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MsgSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MsgSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SEQNUM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MsgSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MsgSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MsgSeqNum *)new FIX::MsgSeqNum((FIX::SEQNUM const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MsgSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MsgSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MsgSeqNum__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MsgSeqNum__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MsgSeqNum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MsgSeqNum::MsgSeqNum()\n"
    "    FIX::MsgSeqNum::MsgSeqNum(FIX::SEQNUM const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MsgSeqNum *arg1 = (FIX::MsgSeqNum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MsgSeqNum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MsgSeqNum" "', argument " "1"" of type '" "FIX::MsgSeqNum *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MsgSeqNum * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MsgSeqNum_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MsgSeqNum, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Signature__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Signature *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Signature")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Signature *)new FIX::Signature();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Signature, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Signature__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Signature *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Signature",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Signature" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Signature" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Signature *)new FIX::Signature((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Signature, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Signature(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Signature__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Signature__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Signature'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Signature::Signature()\n"
    "    FIX::Signature::Signature(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Signature *arg1 = (FIX::Signature *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Signature",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Signature, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Signature" "', argument " "1"" of type '" "FIX::Signature *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Signature * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Signature_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Signature, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Seniority__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Seniority *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Seniority")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Seniority *)new FIX::Seniority();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Seniority, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Seniority__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Seniority *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Seniority",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Seniority" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Seniority" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Seniority *)new FIX::Seniority((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Seniority, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Seniority(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Seniority__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Seniority__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Seniority'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Seniority::Seniority()\n"
    "    FIX::Seniority::Seniority(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Seniority(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Seniority *arg1 = (FIX::Seniority *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Seniority",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Seniority, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Seniority" "', argument " "1"" of type '" "FIX::Seniority *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Seniority * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Seniority_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Seniority, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoRateSources__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRateSources *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoRateSources")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRateSources *)new FIX::NoRateSources();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRateSources, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRateSources__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoRateSources *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRateSources",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoRateSources" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRateSources" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRateSources *)new FIX::NoRateSources((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRateSources, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRateSources(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoRateSources__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoRateSources__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoRateSources'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoRateSources::NoRateSources()\n"
    "    FIX::NoRateSources::NoRateSources(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoRateSources(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRateSources *arg1 = (FIX::NoRateSources *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoRateSources",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoRateSources, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoRateSources" "', argument " "1"" of type '" "FIX::NoRateSources *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoRateSources * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoRateSources_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRateSources, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PriceUnitOfMeasureQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceUnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PriceUnitOfMeasureQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceUnitOfMeasureQty *)new FIX::PriceUnitOfMeasureQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceUnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceUnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PriceUnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PriceUnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriceUnitOfMeasureQty *)new FIX::PriceUnitOfMeasureQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriceUnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriceUnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PriceUnitOfMeasureQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriceUnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PriceUnitOfMeasureQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PriceUnitOfMeasureQty::PriceUnitOfMeasureQty()\n"
    "    FIX::PriceUnitOfMeasureQty::PriceUnitOfMeasureQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PriceUnitOfMeasureQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriceUnitOfMeasureQty *arg1 = (FIX::PriceUnitOfMeasureQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PriceUnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PriceUnitOfMeasureQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PriceUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::PriceUnitOfMeasureQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PriceUnitOfMeasureQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PriceUnitOfMeasureQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PriceUnitOfMeasureQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CollAsgnRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollAsgnRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollAsgnRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollAsgnRefID *)new FIX::CollAsgnRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollAsgnRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollAsgnRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollAsgnRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollAsgnRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollAsgnRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollAsgnRefID *)new FIX::CollAsgnRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollAsgnRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollAsgnRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollAsgnRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollAsgnRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollAsgnRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollAsgnRefID::CollAsgnRefID()\n"
    "    FIX::CollAsgnRefID::CollAsgnRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollAsgnRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollAsgnRefID *arg1 = (FIX::CollAsgnRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollAsgnRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollAsgnRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollAsgnRefID" "', argument " "1"" of type '" "FIX::CollAsgnRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollAsgnRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CollAsgnRefID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CollAsgnRefID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BuyVolume__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BuyVolume *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BuyVolume")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BuyVolume *)new FIX::BuyVolume();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BuyVolume, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BuyVolume__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BuyVolume *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BuyVolume",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BuyVolume" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BuyVolume" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BuyVolume *)new FIX::BuyVolume((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BuyVolume, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BuyVolume(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BuyVolume__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BuyVolume__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BuyVolume'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BuyVolume::BuyVolume()\n"
    "    FIX::BuyVolume::BuyVolume(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BuyVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BuyVolume *arg1 = (FIX::BuyVolume *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BuyVolume",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BuyVolume, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BuyVolume" "', argument " "1"" of type '" "FIX::BuyVolume *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BuyVolume * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BuyVolume_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BuyVolume, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlCurrFxRateCalc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlCurrFxRateCalc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlCurrFxRateCalc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlCurrFxRateCalc *)new FIX::SettlCurrFxRateCalc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlCurrFxRateCalc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrFxRateCalc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlCurrFxRateCalc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlCurrFxRateCalc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlCurrFxRateCalc" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlCurrFxRateCalc" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlCurrFxRateCalc *)new FIX::SettlCurrFxRateCalc((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlCurrFxRateCalc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrFxRateCalc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlCurrFxRateCalc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlCurrFxRateCalc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlCurrFxRateCalc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlCurrFxRateCalc::SettlCurrFxRateCalc()\n"
    "    FIX::SettlCurrFxRateCalc::SettlCurrFxRateCalc(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlCurrFxRateCalc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlCurrFxRateCalc *arg1 = (FIX::SettlCurrFxRateCalc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlCurrFxRateCalc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlCurrFxRateCalc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlCurrFxRateCalc" "', argument " "1"" of type '" "FIX::SettlCurrFxRateCalc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlCurrFxRateCalc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlCurrFxRateCalc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlCurrFxRateCalc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PosMaintStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosMaintStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PosMaintStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosMaintStatus *)new FIX::PosMaintStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosMaintStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PosMaintStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PosMaintStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PosMaintStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PosMaintStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosMaintStatus *)new FIX::PosMaintStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosMaintStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PosMaintStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosMaintStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PosMaintStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PosMaintStatus::PosMaintStatus()\n"
    "    FIX::PosMaintStatus::PosMaintStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PosMaintStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosMaintStatus *arg1 = (FIX::PosMaintStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PosMaintStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PosMaintStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PosMaintStatus" "', argument " "1"" of type '" "FIX::PosMaintStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PosMaintStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PosMaintStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PosMaintStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PriorSpreadIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriorSpreadIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PriorSpreadIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriorSpreadIndicator *)new FIX::PriorSpreadIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriorSpreadIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriorSpreadIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PriorSpreadIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PriorSpreadIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PriorSpreadIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PriorSpreadIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriorSpreadIndicator *)new FIX::PriorSpreadIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriorSpreadIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriorSpreadIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PriorSpreadIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriorSpreadIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PriorSpreadIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PriorSpreadIndicator::PriorSpreadIndicator()\n"
    "    FIX::PriorSpreadIndicator::PriorSpreadIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PriorSpreadIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriorSpreadIndicator *arg1 = (FIX::PriorSpreadIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PriorSpreadIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PriorSpreadIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PriorSpreadIndicator" "', argument " "1"" of type '" "FIX::PriorSpreadIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PriorSpreadIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PriorSpreadIndicator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PriorSpreadIndicator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Benchmark__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Benchmark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Benchmark")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Benchmark *)new FIX::Benchmark();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Benchmark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Benchmark__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Benchmark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Benchmark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Benchmark" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Benchmark" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Benchmark *)new FIX::Benchmark((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Benchmark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Benchmark(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Benchmark__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Benchmark__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Benchmark'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Benchmark::Benchmark()\n"
    "    FIX::Benchmark::Benchmark(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Benchmark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Benchmark *arg1 = (FIX::Benchmark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Benchmark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Benchmark, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Benchmark" "', argument " "1"" of type '" "FIX::Benchmark *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Benchmark * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Benchmark_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Benchmark, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MaturityMonthYearFormat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityMonthYearFormat *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaturityMonthYearFormat")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityMonthYearFormat *)new FIX::MaturityMonthYearFormat();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityMonthYearFormat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYearFormat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaturityMonthYearFormat *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaturityMonthYearFormat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaturityMonthYearFormat" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaturityMonthYearFormat" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityMonthYearFormat *)new FIX::MaturityMonthYearFormat((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityMonthYearFormat, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityMonthYearFormat(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaturityMonthYearFormat__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityMonthYearFormat__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaturityMonthYearFormat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaturityMonthYearFormat::MaturityMonthYearFormat()\n"
    "    FIX::MaturityMonthYearFormat::MaturityMonthYearFormat(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaturityMonthYearFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityMonthYearFormat *arg1 = (FIX::MaturityMonthYearFormat *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaturityMonthYearFormat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaturityMonthYearFormat, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaturityMonthYearFormat" "', argument " "1"" of type '" "FIX::MaturityMonthYearFormat *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaturityMonthYearFormat * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MaturityMonthYearFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MaturityMonthYearFormat, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingTradingSessionID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingTradingSessionID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingTradingSessionID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingTradingSessionID *)new FIX::UnderlyingTradingSessionID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingTradingSessionID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingTradingSessionID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingTradingSessionID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingTradingSessionID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingTradingSessionID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingTradingSessionID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingTradingSessionID *)new FIX::UnderlyingTradingSessionID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingTradingSessionID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingTradingSessionID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingTradingSessionID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingTradingSessionID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingTradingSessionID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingTradingSessionID::UnderlyingTradingSessionID()\n"
    "    FIX::UnderlyingTradingSessionID::UnderlyingTradingSessionID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingTradingSessionID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingTradingSessionID *arg1 = (FIX::UnderlyingTradingSessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingTradingSessionID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingTradingSessionID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingTradingSessionID" "', argument " "1"" of type '" "FIX::UnderlyingTradingSessionID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingTradingSessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingTradingSessionID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingTradingSessionID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TotNoRelatedSym__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoRelatedSym *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotNoRelatedSym")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoRelatedSym *)new FIX::TotNoRelatedSym();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoRelatedSym, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoRelatedSym__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotNoRelatedSym *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotNoRelatedSym",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotNoRelatedSym" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotNoRelatedSym" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoRelatedSym *)new FIX::TotNoRelatedSym((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoRelatedSym, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoRelatedSym(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotNoRelatedSym__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoRelatedSym__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotNoRelatedSym'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotNoRelatedSym::TotNoRelatedSym()\n"
    "    FIX::TotNoRelatedSym::TotNoRelatedSym(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotNoRelatedSym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoRelatedSym *arg1 = (FIX::TotNoRelatedSym *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotNoRelatedSym",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotNoRelatedSym, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotNoRelatedSym" "', argument " "1"" of type '" "FIX::TotNoRelatedSym *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotNoRelatedSym * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TotNoRelatedSym_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TotNoRelatedSym, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StateOrProvinceOfIssue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StateOrProvinceOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StateOrProvinceOfIssue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StateOrProvinceOfIssue *)new FIX::StateOrProvinceOfIssue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StateOrProvinceOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StateOrProvinceOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StateOrProvinceOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StateOrProvinceOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StateOrProvinceOfIssue *)new FIX::StateOrProvinceOfIssue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StateOrProvinceOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StateOrProvinceOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StateOrProvinceOfIssue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StateOrProvinceOfIssue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StateOrProvinceOfIssue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StateOrProvinceOfIssue::StateOrProvinceOfIssue()\n"
    "    FIX::StateOrProvinceOfIssue::StateOrProvinceOfIssue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StateOrProvinceOfIssue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StateOrProvinceOfIssue *arg1 = (FIX::StateOrProvinceOfIssue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StateOrProvinceOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StateOrProvinceOfIssue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StateOrProvinceOfIssue" "', argument " "1"" of type '" "FIX::StateOrProvinceOfIssue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StateOrProvinceOfIssue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StateOrProvinceOfIssue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__StateOrProvinceOfIssue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeInstrRegistry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrRegistry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeInstrRegistry")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrRegistry *)new FIX::DerivativeInstrRegistry();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrRegistry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrRegistry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeInstrRegistry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeInstrRegistry",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeInstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeInstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrRegistry *)new FIX::DerivativeInstrRegistry((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrRegistry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrRegistry(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeInstrRegistry__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrRegistry__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeInstrRegistry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeInstrRegistry::DerivativeInstrRegistry()\n"
    "    FIX::DerivativeInstrRegistry::DerivativeInstrRegistry(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeInstrRegistry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrRegistry *arg1 = (FIX::DerivativeInstrRegistry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeInstrRegistry",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeInstrRegistry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeInstrRegistry" "', argument " "1"" of type '" "FIX::DerivativeInstrRegistry *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeInstrRegistry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeInstrRegistry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeInstrRegistry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegBidForwardPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegBidForwardPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegBidForwardPoints")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegBidForwardPoints *)new FIX::LegBidForwardPoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegBidForwardPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBidForwardPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegBidForwardPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegBidForwardPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegBidForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegBidForwardPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegBidForwardPoints *)new FIX::LegBidForwardPoints((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegBidForwardPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegBidForwardPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegBidForwardPoints__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegBidForwardPoints__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegBidForwardPoints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegBidForwardPoints::LegBidForwardPoints()\n"
    "    FIX::LegBidForwardPoints::LegBidForwardPoints(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegBidForwardPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegBidForwardPoints *arg1 = (FIX::LegBidForwardPoints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegBidForwardPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegBidForwardPoints, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegBidForwardPoints" "', argument " "1"" of type '" "FIX::LegBidForwardPoints *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegBidForwardPoints * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegBidForwardPoints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegBidForwardPoints, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ManualOrderIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ManualOrderIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ManualOrderIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ManualOrderIndicator *)new FIX::ManualOrderIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ManualOrderIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ManualOrderIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ManualOrderIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ManualOrderIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ManualOrderIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ManualOrderIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ManualOrderIndicator *)new FIX::ManualOrderIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ManualOrderIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ManualOrderIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ManualOrderIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ManualOrderIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ManualOrderIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ManualOrderIndicator::ManualOrderIndicator()\n"
    "    FIX::ManualOrderIndicator::ManualOrderIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ManualOrderIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ManualOrderIndicator *arg1 = (FIX::ManualOrderIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ManualOrderIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ManualOrderIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ManualOrderIndicator" "', argument " "1"" of type '" "FIX::ManualOrderIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ManualOrderIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ManualOrderIndicator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ManualOrderIndicator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NetMoney__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NetMoney *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NetMoney")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NetMoney *)new FIX::NetMoney();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NetMoney, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetMoney__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NetMoney *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NetMoney",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NetMoney" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NetMoney" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NetMoney *)new FIX::NetMoney((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NetMoney, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetMoney(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NetMoney__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NetMoney__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NetMoney'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NetMoney::NetMoney()\n"
    "    FIX::NetMoney::NetMoney(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NetMoney(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NetMoney *arg1 = (FIX::NetMoney *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NetMoney",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NetMoney, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NetMoney" "', argument " "1"" of type '" "FIX::NetMoney *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NetMoney * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NetMoney_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NetMoney, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegalConfirm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegalConfirm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegalConfirm")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegalConfirm *)new FIX::LegalConfirm();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegalConfirm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegalConfirm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegalConfirm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegalConfirm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegalConfirm" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegalConfirm" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegalConfirm *)new FIX::LegalConfirm((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegalConfirm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegalConfirm(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegalConfirm__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegalConfirm__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegalConfirm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegalConfirm::LegalConfirm()\n"
    "    FIX::LegalConfirm::LegalConfirm(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegalConfirm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegalConfirm *arg1 = (FIX::LegalConfirm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegalConfirm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegalConfirm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegalConfirm" "', argument " "1"" of type '" "FIX::LegalConfirm *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegalConfirm * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegalConfirm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegalConfirm, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CountryOfIssue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CountryOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CountryOfIssue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CountryOfIssue *)new FIX::CountryOfIssue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CountryOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CountryOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::COUNTRY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CountryOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CountryOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__COUNTRY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CountryOfIssue" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::COUNTRY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CountryOfIssue *)new FIX::CountryOfIssue((FIX::COUNTRY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CountryOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CountryOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CountryOfIssue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__COUNTRY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CountryOfIssue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CountryOfIssue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CountryOfIssue::CountryOfIssue()\n"
    "    FIX::CountryOfIssue::CountryOfIssue(FIX::COUNTRY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CountryOfIssue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CountryOfIssue *arg1 = (FIX::CountryOfIssue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CountryOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CountryOfIssue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CountryOfIssue" "', argument " "1"" of type '" "FIX::CountryOfIssue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CountryOfIssue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CountryOfIssue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CountryOfIssue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ApplReportType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplReportType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplReportType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplReportType *)new FIX::ApplReportType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplReportType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReportType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplReportType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplReportType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplReportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplReportType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplReportType *)new FIX::ApplReportType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplReportType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReportType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplReportType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplReportType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplReportType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplReportType::ApplReportType()\n"
    "    FIX::ApplReportType::ApplReportType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplReportType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplReportType *arg1 = (FIX::ApplReportType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplReportType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplReportType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplReportType" "', argument " "1"" of type '" "FIX::ApplReportType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplReportType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ApplReportType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ApplReportType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RootPartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RootPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RootPartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RootPartyID *)new FIX::RootPartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RootPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RootPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RootPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RootPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RootPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RootPartyID *)new FIX::RootPartyID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RootPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RootPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RootPartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RootPartyID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RootPartyID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RootPartyID::RootPartyID()\n"
    "    FIX::RootPartyID::RootPartyID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RootPartyID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RootPartyID *arg1 = (FIX::RootPartyID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RootPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RootPartyID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RootPartyID" "', argument " "1"" of type '" "FIX::RootPartyID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RootPartyID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RootPartyID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RootPartyID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingQty *)new FIX::UnderlyingQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingQty *)new FIX::UnderlyingQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingQty::UnderlyingQty()\n"
    "    FIX::UnderlyingQty::UnderlyingQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingQty *arg1 = (FIX::UnderlyingQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingQty" "', argument " "1"" of type '" "FIX::UnderlyingQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ApplQueueDepth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplQueueDepth *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplQueueDepth")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplQueueDepth *)new FIX::ApplQueueDepth();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplQueueDepth, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueDepth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplQueueDepth *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplQueueDepth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplQueueDepth" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplQueueDepth" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplQueueDepth *)new FIX::ApplQueueDepth((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplQueueDepth, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueDepth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplQueueDepth__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplQueueDepth__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplQueueDepth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplQueueDepth::ApplQueueDepth()\n"
    "    FIX::ApplQueueDepth::ApplQueueDepth(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplQueueDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplQueueDepth *arg1 = (FIX::ApplQueueDepth *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplQueueDepth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplQueueDepth, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplQueueDepth" "', argument " "1"" of type '" "FIX::ApplQueueDepth *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplQueueDepth * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ApplQueueDepth_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ApplQueueDepth, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StopPx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StopPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StopPx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StopPx *)new FIX::StopPx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StopPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StopPx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StopPx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StopPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StopPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StopPx" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StopPx *)new FIX::StopPx((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StopPx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StopPx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StopPx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StopPx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StopPx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StopPx::StopPx()\n"
    "    FIX::StopPx::StopPx(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StopPx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StopPx *arg1 = (FIX::StopPx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StopPx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StopPx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopPx" "', argument " "1"" of type '" "FIX::StopPx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StopPx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StopPx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__StopPx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ReportToExch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ReportToExch *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ReportToExch")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ReportToExch *)new FIX::ReportToExch();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ReportToExch, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReportToExch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ReportToExch *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ReportToExch",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ReportToExch" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ReportToExch" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ReportToExch *)new FIX::ReportToExch((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ReportToExch, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReportToExch(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ReportToExch__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ReportToExch__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ReportToExch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ReportToExch::ReportToExch()\n"
    "    FIX::ReportToExch::ReportToExch(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ReportToExch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ReportToExch *arg1 = (FIX::ReportToExch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ReportToExch",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ReportToExch, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReportToExch" "', argument " "1"" of type '" "FIX::ReportToExch *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ReportToExch * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ReportToExch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ReportToExch, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ContraryInstructionIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContraryInstructionIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ContraryInstructionIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContraryInstructionIndicator *)new FIX::ContraryInstructionIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContraryInstructionIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraryInstructionIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContraryInstructionIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContraryInstructionIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContraryInstructionIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContraryInstructionIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContraryInstructionIndicator *)new FIX::ContraryInstructionIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContraryInstructionIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContraryInstructionIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ContraryInstructionIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContraryInstructionIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContraryInstructionIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ContraryInstructionIndicator::ContraryInstructionIndicator()\n"
    "    FIX::ContraryInstructionIndicator::ContraryInstructionIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ContraryInstructionIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContraryInstructionIndicator *arg1 = (FIX::ContraryInstructionIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContraryInstructionIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ContraryInstructionIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContraryInstructionIndicator" "', argument " "1"" of type '" "FIX::ContraryInstructionIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ContraryInstructionIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ContraryInstructionIndicator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ContraryInstructionIndicator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncodedListStatusTextLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedListStatusTextLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedListStatusTextLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedListStatusTextLen *)new FIX::EncodedListStatusTextLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedListStatusTextLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListStatusTextLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedListStatusTextLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedListStatusTextLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedListStatusTextLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedListStatusTextLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedListStatusTextLen *)new FIX::EncodedListStatusTextLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedListStatusTextLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListStatusTextLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedListStatusTextLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedListStatusTextLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedListStatusTextLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedListStatusTextLen::EncodedListStatusTextLen()\n"
    "    FIX::EncodedListStatusTextLen::EncodedListStatusTextLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedListStatusTextLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedListStatusTextLen *arg1 = (FIX::EncodedListStatusTextLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedListStatusTextLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedListStatusTextLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedListStatusTextLen" "', argument " "1"" of type '" "FIX::EncodedListStatusTextLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedListStatusTextLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncodedListStatusTextLen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedListStatusTextLen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXMLSchema__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityXMLSchema *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSecurityXMLSchema")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityXMLSchema *)new FIX::DerivativeSecurityXMLSchema();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityXMLSchema, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXMLSchema__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSecurityXMLSchema *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSecurityXMLSchema",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSecurityXMLSchema" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSecurityXMLSchema" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityXMLSchema *)new FIX::DerivativeSecurityXMLSchema((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityXMLSchema, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXMLSchema(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSecurityXMLSchema__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityXMLSchema__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSecurityXMLSchema'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSecurityXMLSchema::DerivativeSecurityXMLSchema()\n"
    "    FIX::DerivativeSecurityXMLSchema::DerivativeSecurityXMLSchema(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSecurityXMLSchema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityXMLSchema *arg1 = (FIX::DerivativeSecurityXMLSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSecurityXMLSchema",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSecurityXMLSchema, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSecurityXMLSchema" "', argument " "1"" of type '" "FIX::DerivativeSecurityXMLSchema *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSecurityXMLSchema * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeSecurityXMLSchema_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeSecurityXMLSchema, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoRelatedSym__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRelatedSym *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoRelatedSym")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelatedSym *)new FIX::NoRelatedSym();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelatedSym, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedSym__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoRelatedSym *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRelatedSym",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoRelatedSym" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRelatedSym" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRelatedSym *)new FIX::NoRelatedSym((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRelatedSym, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRelatedSym(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoRelatedSym__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoRelatedSym__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoRelatedSym'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoRelatedSym::NoRelatedSym()\n"
    "    FIX::NoRelatedSym::NoRelatedSym(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoRelatedSym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRelatedSym *arg1 = (FIX::NoRelatedSym *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoRelatedSym",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoRelatedSym, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoRelatedSym" "', argument " "1"" of type '" "FIX::NoRelatedSym *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoRelatedSym * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoRelatedSym_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRelatedSym, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocRejCode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocRejCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocRejCode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocRejCode *)new FIX::AllocRejCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocRejCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocRejCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocRejCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocRejCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocRejCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocRejCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocRejCode *)new FIX::AllocRejCode((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocRejCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocRejCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocRejCode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocRejCode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocRejCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocRejCode::AllocRejCode()\n"
    "    FIX::AllocRejCode::AllocRejCode(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocRejCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocRejCode *arg1 = (FIX::AllocRejCode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocRejCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocRejCode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocRejCode" "', argument " "1"" of type '" "FIX::AllocRejCode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocRejCode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocRejCode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocRejCode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSecurityAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecurityAltID *)new FIX::UnderlyingSecurityAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSecurityAltID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecurityAltID *)new FIX::UnderlyingSecurityAltID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSecurityAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecurityAltID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSecurityAltID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSecurityAltID::UnderlyingSecurityAltID()\n"
    "    FIX::UnderlyingSecurityAltID::UnderlyingSecurityAltID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSecurityAltID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecurityAltID *arg1 = (FIX::UnderlyingSecurityAltID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSecurityAltID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSecurityAltID" "', argument " "1"" of type '" "FIX::UnderlyingSecurityAltID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSecurityAltID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingSecurityAltID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingSecurityAltID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RefOrdIDReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefOrdIDReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefOrdIDReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefOrdIDReason *)new FIX::RefOrdIDReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefOrdIDReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefOrdIDReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefOrdIDReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefOrdIDReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefOrdIDReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefOrdIDReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefOrdIDReason *)new FIX::RefOrdIDReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefOrdIDReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefOrdIDReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefOrdIDReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefOrdIDReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefOrdIDReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefOrdIDReason::RefOrdIDReason()\n"
    "    FIX::RefOrdIDReason::RefOrdIDReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefOrdIDReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefOrdIDReason *arg1 = (FIX::RefOrdIDReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefOrdIDReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefOrdIDReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefOrdIDReason" "', argument " "1"" of type '" "FIX::RefOrdIDReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefOrdIDReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RefOrdIDReason_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RefOrdIDReason, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrumentPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeInstrumentPartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrumentPartyID *)new FIX::DerivativeInstrumentPartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrumentPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeInstrumentPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeInstrumentPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeInstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeInstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrumentPartyID *)new FIX::DerivativeInstrumentPartyID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrumentPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeInstrumentPartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrumentPartyID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeInstrumentPartyID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeInstrumentPartyID::DerivativeInstrumentPartyID()\n"
    "    FIX::DerivativeInstrumentPartyID::DerivativeInstrumentPartyID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeInstrumentPartyID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrumentPartyID *arg1 = (FIX::DerivativeInstrumentPartyID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeInstrumentPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeInstrumentPartyID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeInstrumentPartyID" "', argument " "1"" of type '" "FIX::DerivativeInstrumentPartyID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeInstrumentPartyID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeInstrumentPartyID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeInstrumentPartyID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityXMLSchema__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityXMLSchema *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityXMLSchema")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityXMLSchema *)new FIX::SecurityXMLSchema();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityXMLSchema, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityXMLSchema__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityXMLSchema *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityXMLSchema",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityXMLSchema" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityXMLSchema" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityXMLSchema *)new FIX::SecurityXMLSchema((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityXMLSchema, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityXMLSchema(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityXMLSchema__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityXMLSchema__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityXMLSchema'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityXMLSchema::SecurityXMLSchema()\n"
    "    FIX::SecurityXMLSchema::SecurityXMLSchema(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityXMLSchema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityXMLSchema *arg1 = (FIX::SecurityXMLSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityXMLSchema",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityXMLSchema, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityXMLSchema" "', argument " "1"" of type '" "FIX::SecurityXMLSchema *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityXMLSchema * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityXMLSchema_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityXMLSchema, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RefOrderIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefOrderIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefOrderIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefOrderIDSource *)new FIX::RefOrderIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefOrderIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefOrderIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefOrderIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefOrderIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefOrderIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefOrderIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefOrderIDSource *)new FIX::RefOrderIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefOrderIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefOrderIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefOrderIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefOrderIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefOrderIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefOrderIDSource::RefOrderIDSource()\n"
    "    FIX::RefOrderIDSource::RefOrderIDSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefOrderIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefOrderIDSource *arg1 = (FIX::RefOrderIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefOrderIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefOrderIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefOrderIDSource" "', argument " "1"" of type '" "FIX::RefOrderIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefOrderIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RefOrderIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RefOrderIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NTPositionLimit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NTPositionLimit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NTPositionLimit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NTPositionLimit *)new FIX::NTPositionLimit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NTPositionLimit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NTPositionLimit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NTPositionLimit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NTPositionLimit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NTPositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NTPositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NTPositionLimit *)new FIX::NTPositionLimit((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NTPositionLimit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NTPositionLimit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NTPositionLimit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NTPositionLimit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NTPositionLimit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NTPositionLimit::NTPositionLimit()\n"
    "    FIX::NTPositionLimit::NTPositionLimit(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NTPositionLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NTPositionLimit *arg1 = (FIX::NTPositionLimit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NTPositionLimit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NTPositionLimit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NTPositionLimit" "', argument " "1"" of type '" "FIX::NTPositionLimit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NTPositionLimit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NTPositionLimit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NTPositionLimit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EndAccruedInterestAmt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EndAccruedInterestAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EndAccruedInterestAmt")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EndAccruedInterestAmt *)new FIX::EndAccruedInterestAmt();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EndAccruedInterestAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndAccruedInterestAmt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EndAccruedInterestAmt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EndAccruedInterestAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EndAccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EndAccruedInterestAmt" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EndAccruedInterestAmt *)new FIX::EndAccruedInterestAmt((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EndAccruedInterestAmt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EndAccruedInterestAmt(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EndAccruedInterestAmt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EndAccruedInterestAmt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EndAccruedInterestAmt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EndAccruedInterestAmt::EndAccruedInterestAmt()\n"
    "    FIX::EndAccruedInterestAmt::EndAccruedInterestAmt(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EndAccruedInterestAmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EndAccruedInterestAmt *arg1 = (FIX::EndAccruedInterestAmt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EndAccruedInterestAmt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EndAccruedInterestAmt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EndAccruedInterestAmt" "', argument " "1"" of type '" "FIX::EndAccruedInterestAmt *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EndAccruedInterestAmt * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EndAccruedInterestAmt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EndAccruedInterestAmt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AccruedInterestRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AccruedInterestRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AccruedInterestRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AccruedInterestRate *)new FIX::AccruedInterestRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AccruedInterestRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AccruedInterestRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AccruedInterestRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AccruedInterestRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AccruedInterestRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AccruedInterestRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AccruedInterestRate *)new FIX::AccruedInterestRate((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AccruedInterestRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AccruedInterestRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AccruedInterestRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AccruedInterestRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AccruedInterestRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AccruedInterestRate::AccruedInterestRate()\n"
    "    FIX::AccruedInterestRate::AccruedInterestRate(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AccruedInterestRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AccruedInterestRate *arg1 = (FIX::AccruedInterestRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AccruedInterestRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AccruedInterestRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AccruedInterestRate" "', argument " "1"" of type '" "FIX::AccruedInterestRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AccruedInterestRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AccruedInterestRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AccruedInterestRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LastCapacity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastCapacity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastCapacity")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastCapacity *)new FIX::LastCapacity();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastCapacity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastCapacity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastCapacity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastCapacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastCapacity" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastCapacity" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastCapacity *)new FIX::LastCapacity((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastCapacity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastCapacity(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastCapacity__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastCapacity__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastCapacity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastCapacity::LastCapacity()\n"
    "    FIX::LastCapacity::LastCapacity(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastCapacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastCapacity *arg1 = (FIX::LastCapacity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastCapacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastCapacity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastCapacity" "', argument " "1"" of type '" "FIX::LastCapacity *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastCapacity * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LastCapacity_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LastCapacity, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartySubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingInstrumentPartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingInstrumentPartySubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingInstrumentPartySubID *)new FIX::UnderlyingInstrumentPartySubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingInstrumentPartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingInstrumentPartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingInstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingInstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingInstrumentPartySubID *)new FIX::UnderlyingInstrumentPartySubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingInstrumentPartySubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingInstrumentPartySubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingInstrumentPartySubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingInstrumentPartySubID::UnderlyingInstrumentPartySubID()\n"
    "    FIX::UnderlyingInstrumentPartySubID::UnderlyingInstrumentPartySubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingInstrumentPartySubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingInstrumentPartySubID *arg1 = (FIX::UnderlyingInstrumentPartySubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingInstrumentPartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingInstrumentPartySubID" "', argument " "1"" of type '" "FIX::UnderlyingInstrumentPartySubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingInstrumentPartySubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingInstrumentPartySubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingInstrumentPartySubID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoFills__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoFills *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoFills")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoFills *)new FIX::NoFills();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoFills, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoFills__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoFills *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoFills",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoFills" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoFills" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoFills *)new FIX::NoFills((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoFills, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoFills(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoFills__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoFills__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoFills'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoFills::NoFills()\n"
    "    FIX::NoFills::NoFills(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoFills(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoFills *arg1 = (FIX::NoFills *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoFills",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoFills, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoFills" "', argument " "1"" of type '" "FIX::NoFills *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoFills * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoFills_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoFills, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoOrdTypeRules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoOrdTypeRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoOrdTypeRules")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoOrdTypeRules *)new FIX::NoOrdTypeRules();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoOrdTypeRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOrdTypeRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoOrdTypeRules *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoOrdTypeRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoOrdTypeRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoOrdTypeRules" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoOrdTypeRules *)new FIX::NoOrdTypeRules((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoOrdTypeRules, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoOrdTypeRules(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoOrdTypeRules__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoOrdTypeRules__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoOrdTypeRules'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoOrdTypeRules::NoOrdTypeRules()\n"
    "    FIX::NoOrdTypeRules::NoOrdTypeRules(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoOrdTypeRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoOrdTypeRules *arg1 = (FIX::NoOrdTypeRules *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoOrdTypeRules",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoOrdTypeRules, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoOrdTypeRules" "', argument " "1"" of type '" "FIX::NoOrdTypeRules *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoOrdTypeRules * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoOrdTypeRules_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoOrdTypeRules, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_InstrumentPartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrumentPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InstrumentPartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrumentPartyID *)new FIX::InstrumentPartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrumentPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InstrumentPartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InstrumentPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InstrumentPartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrumentPartyID *)new FIX::InstrumentPartyID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrumentPartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrumentPartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InstrumentPartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrumentPartyID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InstrumentPartyID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InstrumentPartyID::InstrumentPartyID()\n"
    "    FIX::InstrumentPartyID::InstrumentPartyID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InstrumentPartyID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrumentPartyID *arg1 = (FIX::InstrumentPartyID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InstrumentPartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InstrumentPartyID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InstrumentPartyID" "', argument " "1"" of type '" "FIX::InstrumentPartyID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InstrumentPartyID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InstrumentPartyID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__InstrumentPartyID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MarginRatio__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarginRatio *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MarginRatio")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarginRatio *)new FIX::MarginRatio();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarginRatio, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarginRatio__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MarginRatio *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MarginRatio",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MarginRatio" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MarginRatio" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MarginRatio *)new FIX::MarginRatio((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MarginRatio, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MarginRatio(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MarginRatio__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MarginRatio__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MarginRatio'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MarginRatio::MarginRatio()\n"
    "    FIX::MarginRatio::MarginRatio(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MarginRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MarginRatio *arg1 = (FIX::MarginRatio *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MarginRatio",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MarginRatio, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MarginRatio" "', argument " "1"" of type '" "FIX::MarginRatio *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MarginRatio * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MarginRatio_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MarginRatio, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RefTagID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefTagID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RefTagID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefTagID *)new FIX::RefTagID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefTagID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefTagID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::RefTagID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RefTagID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RefTagID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RefTagID" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::RefTagID *)new FIX::RefTagID((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__RefTagID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RefTagID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_RefTagID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RefTagID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RefTagID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::RefTagID::RefTagID()\n"
    "    FIX::RefTagID::RefTagID(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RefTagID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::RefTagID *arg1 = (FIX::RefTagID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RefTagID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__RefTagID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RefTagID" "', argument " "1"" of type '" "FIX::RefTagID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::RefTagID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RefTagID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__RefTagID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoRoutingIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRoutingIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoRoutingIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRoutingIDs *)new FIX::NoRoutingIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRoutingIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRoutingIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoRoutingIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRoutingIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoRoutingIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRoutingIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRoutingIDs *)new FIX::NoRoutingIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRoutingIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRoutingIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoRoutingIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoRoutingIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoRoutingIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoRoutingIDs::NoRoutingIDs()\n"
    "    FIX::NoRoutingIDs::NoRoutingIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoRoutingIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRoutingIDs *arg1 = (FIX::NoRoutingIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoRoutingIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoRoutingIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoRoutingIDs" "', argument " "1"" of type '" "FIX::NoRoutingIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoRoutingIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoRoutingIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRoutingIDs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CouponRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CouponRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CouponRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CouponRate *)new FIX::CouponRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CouponRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CouponRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CouponRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CouponRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CouponRate *)new FIX::CouponRate((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CouponRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CouponRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CouponRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CouponRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CouponRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CouponRate::CouponRate()\n"
    "    FIX::CouponRate::CouponRate(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CouponRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CouponRate *arg1 = (FIX::CouponRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CouponRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CouponRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CouponRate" "', argument " "1"" of type '" "FIX::CouponRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CouponRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CouponRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CouponRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoApplIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoApplIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoApplIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoApplIDs *)new FIX::NoApplIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoApplIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoApplIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoApplIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoApplIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoApplIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoApplIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoApplIDs *)new FIX::NoApplIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoApplIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoApplIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoApplIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoApplIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoApplIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoApplIDs::NoApplIDs()\n"
    "    FIX::NoApplIDs::NoApplIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoApplIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoApplIDs *arg1 = (FIX::NoApplIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoApplIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoApplIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoApplIDs" "', argument " "1"" of type '" "FIX::NoApplIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoApplIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoApplIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoApplIDs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeContractSettlMonth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeContractSettlMonth *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeContractSettlMonth")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeContractSettlMonth *)new FIX::DerivativeContractSettlMonth();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeContractSettlMonth, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeContractSettlMonth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MONTHYEAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeContractSettlMonth *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeContractSettlMonth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MONTHYEAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeContractSettlMonth" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeContractSettlMonth" "', argument " "1"" of type '" "FIX::MONTHYEAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MONTHYEAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeContractSettlMonth *)new FIX::DerivativeContractSettlMonth((FIX::MONTHYEAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeContractSettlMonth, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeContractSettlMonth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeContractSettlMonth__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MONTHYEAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeContractSettlMonth__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeContractSettlMonth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeContractSettlMonth::DerivativeContractSettlMonth()\n"
    "    FIX::DerivativeContractSettlMonth::DerivativeContractSettlMonth(FIX::MONTHYEAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeContractSettlMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeContractSettlMonth *arg1 = (FIX::DerivativeContractSettlMonth *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeContractSettlMonth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeContractSettlMonth, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeContractSettlMonth" "', argument " "1"" of type '" "FIX::DerivativeContractSettlMonth *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeContractSettlMonth * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeContractSettlMonth_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeContractSettlMonth, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_InstrAttribType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrAttribType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InstrAttribType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrAttribType *)new FIX::InstrAttribType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrAttribType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrAttribType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::InstrAttribType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InstrAttribType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InstrAttribType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InstrAttribType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::InstrAttribType *)new FIX::InstrAttribType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__InstrAttribType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InstrAttribType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_InstrAttribType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_InstrAttribType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InstrAttribType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::InstrAttribType::InstrAttribType()\n"
    "    FIX::InstrAttribType::InstrAttribType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_InstrAttribType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::InstrAttribType *arg1 = (FIX::InstrAttribType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InstrAttribType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__InstrAttribType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InstrAttribType" "', argument " "1"" of type '" "FIX::InstrAttribType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::InstrAttribType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InstrAttribType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__InstrAttribType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Product__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Product *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Product")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Product *)new FIX::Product();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Product, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Product__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Product *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Product",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Product" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Product" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Product *)new FIX::Product((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Product, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Product(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Product__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Product__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Product'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Product::Product()\n"
    "    FIX::Product::Product(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Product(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Product *arg1 = (FIX::Product *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Product",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Product, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Product" "', argument " "1"" of type '" "FIX::Product *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Product * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Product_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Product, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocShares__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocShares *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocShares")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocShares *)new FIX::AllocShares();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocShares, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocShares__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocShares *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocShares",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocShares" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocShares" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocShares *)new FIX::AllocShares((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocShares, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocShares(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocShares__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocShares__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocShares'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocShares::AllocShares()\n"
    "    FIX::AllocShares::AllocShares(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocShares(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocShares *arg1 = (FIX::AllocShares *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocShares",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocShares, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocShares" "', argument " "1"" of type '" "FIX::AllocShares *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocShares * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocShares_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocShares, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoQuoteEntries__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoQuoteEntries *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoQuoteEntries")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoQuoteEntries *)new FIX::NoQuoteEntries();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoQuoteEntries, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoQuoteEntries__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoQuoteEntries *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoQuoteEntries",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoQuoteEntries" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoQuoteEntries" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoQuoteEntries *)new FIX::NoQuoteEntries((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoQuoteEntries, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoQuoteEntries(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoQuoteEntries__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoQuoteEntries__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoQuoteEntries'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoQuoteEntries::NoQuoteEntries()\n"
    "    FIX::NoQuoteEntries::NoQuoteEntries(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoQuoteEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoQuoteEntries *arg1 = (FIX::NoQuoteEntries *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoQuoteEntries",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoQuoteEntries, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoQuoteEntries" "', argument " "1"" of type '" "FIX::NoQuoteEntries *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoQuoteEntries * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoQuoteEntries_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoQuoteEntries, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DefaultCstmApplVerID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DefaultCstmApplVerID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DefaultCstmApplVerID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DefaultCstmApplVerID *)new FIX::DefaultCstmApplVerID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DefaultCstmApplVerID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultCstmApplVerID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DefaultCstmApplVerID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DefaultCstmApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DefaultCstmApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DefaultCstmApplVerID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DefaultCstmApplVerID *)new FIX::DefaultCstmApplVerID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DefaultCstmApplVerID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DefaultCstmApplVerID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DefaultCstmApplVerID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DefaultCstmApplVerID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DefaultCstmApplVerID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DefaultCstmApplVerID::DefaultCstmApplVerID()\n"
    "    FIX::DefaultCstmApplVerID::DefaultCstmApplVerID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DefaultCstmApplVerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DefaultCstmApplVerID *arg1 = (FIX::DefaultCstmApplVerID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DefaultCstmApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DefaultCstmApplVerID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DefaultCstmApplVerID" "', argument " "1"" of type '" "FIX::DefaultCstmApplVerID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DefaultCstmApplVerID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DefaultCstmApplVerID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DefaultCstmApplVerID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeListMethod__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeListMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeListMethod")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeListMethod *)new FIX::DerivativeListMethod();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeListMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeListMethod__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeListMethod *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeListMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeListMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeListMethod" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeListMethod *)new FIX::DerivativeListMethod((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeListMethod, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeListMethod(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeListMethod__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeListMethod__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeListMethod'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeListMethod::DerivativeListMethod()\n"
    "    FIX::DerivativeListMethod::DerivativeListMethod(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeListMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeListMethod *arg1 = (FIX::DerivativeListMethod *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeListMethod",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeListMethod, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeListMethod" "', argument " "1"" of type '" "FIX::DerivativeListMethod *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeListMethod * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeListMethod_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeListMethod, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXMLLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityXMLLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSecurityXMLLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityXMLLen *)new FIX::DerivativeSecurityXMLLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityXMLLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXMLLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSecurityXMLLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSecurityXMLLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSecurityXMLLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSecurityXMLLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityXMLLen *)new FIX::DerivativeSecurityXMLLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityXMLLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityXMLLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSecurityXMLLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityXMLLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSecurityXMLLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSecurityXMLLen::DerivativeSecurityXMLLen()\n"
    "    FIX::DerivativeSecurityXMLLen::DerivativeSecurityXMLLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSecurityXMLLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityXMLLen *arg1 = (FIX::DerivativeSecurityXMLLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSecurityXMLLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSecurityXMLLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSecurityXMLLen" "', argument " "1"" of type '" "FIX::DerivativeSecurityXMLLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSecurityXMLLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeSecurityXMLLen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeSecurityXMLLen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegDatedDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegDatedDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegDatedDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegDatedDate *)new FIX::LegDatedDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegDatedDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegDatedDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegDatedDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegDatedDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegDatedDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegDatedDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegDatedDate *)new FIX::LegDatedDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegDatedDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegDatedDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegDatedDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegDatedDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegDatedDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegDatedDate::LegDatedDate()\n"
    "    FIX::LegDatedDate::LegDatedDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegDatedDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegDatedDate *arg1 = (FIX::LegDatedDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegDatedDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegDatedDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegDatedDate" "', argument " "1"" of type '" "FIX::LegDatedDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegDatedDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegDatedDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegDatedDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Nested2PartyIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested2PartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested2PartyIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested2PartyIDSource *)new FIX::Nested2PartyIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested2PartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartyIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested2PartyIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested2PartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested2PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested2PartyIDSource" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested2PartyIDSource *)new FIX::Nested2PartyIDSource((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested2PartyIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartyIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested2PartyIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested2PartyIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested2PartyIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested2PartyIDSource::Nested2PartyIDSource()\n"
    "    FIX::Nested2PartyIDSource::Nested2PartyIDSource(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested2PartyIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested2PartyIDSource *arg1 = (FIX::Nested2PartyIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested2PartyIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested2PartyIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested2PartyIDSource" "', argument " "1"" of type '" "FIX::Nested2PartyIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested2PartyIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Nested2PartyIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Nested2PartyIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingInstrRegistry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingInstrRegistry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingInstrRegistry")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingInstrRegistry *)new FIX::UnderlyingInstrRegistry();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingInstrRegistry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrRegistry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingInstrRegistry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingInstrRegistry",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingInstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingInstrRegistry" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingInstrRegistry *)new FIX::UnderlyingInstrRegistry((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingInstrRegistry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrRegistry(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingInstrRegistry__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingInstrRegistry__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingInstrRegistry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingInstrRegistry::UnderlyingInstrRegistry()\n"
    "    FIX::UnderlyingInstrRegistry::UnderlyingInstrRegistry(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingInstrRegistry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingInstrRegistry *arg1 = (FIX::UnderlyingInstrRegistry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingInstrRegistry",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingInstrRegistry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingInstrRegistry" "', argument " "1"" of type '" "FIX::UnderlyingInstrRegistry *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingInstrRegistry * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingInstrRegistry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingInstrRegistry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_IssueDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IssueDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IssueDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IssueDate *)new FIX::IssueDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IssueDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IssueDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IssueDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IssueDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IssueDate *)new FIX::IssueDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IssueDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IssueDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IssueDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IssueDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IssueDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IssueDate::IssueDate()\n"
    "    FIX::IssueDate::IssueDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IssueDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IssueDate *arg1 = (FIX::IssueDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IssueDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IssueDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IssueDate" "', argument " "1"" of type '" "FIX::IssueDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IssueDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IssueDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__IssueDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityTradingStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityTradingStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityTradingStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityTradingStatus *)new FIX::SecurityTradingStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityTradingStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityTradingStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityTradingStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityTradingStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityTradingStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityTradingStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityTradingStatus *)new FIX::SecurityTradingStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityTradingStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityTradingStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityTradingStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityTradingStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityTradingStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityTradingStatus::SecurityTradingStatus()\n"
    "    FIX::SecurityTradingStatus::SecurityTradingStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityTradingStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityTradingStatus *arg1 = (FIX::SecurityTradingStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityTradingStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityTradingStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityTradingStatus" "', argument " "1"" of type '" "FIX::SecurityTradingStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityTradingStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityTradingStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityTradingStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegOptAttribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegOptAttribute *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegOptAttribute")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegOptAttribute *)new FIX::LegOptAttribute();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegOptAttribute, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOptAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegOptAttribute *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegOptAttribute",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegOptAttribute" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegOptAttribute *)new FIX::LegOptAttribute((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegOptAttribute, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegOptAttribute(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegOptAttribute__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegOptAttribute__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegOptAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegOptAttribute::LegOptAttribute()\n"
    "    FIX::LegOptAttribute::LegOptAttribute(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegOptAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegOptAttribute *arg1 = (FIX::LegOptAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegOptAttribute",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegOptAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegOptAttribute" "', argument " "1"" of type '" "FIX::LegOptAttribute *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegOptAttribute * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegOptAttribute_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegOptAttribute, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MaxFloor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaxFloor *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaxFloor")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaxFloor *)new FIX::MaxFloor();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaxFloor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxFloor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaxFloor *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaxFloor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaxFloor" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaxFloor" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaxFloor *)new FIX::MaxFloor((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaxFloor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaxFloor(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaxFloor__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaxFloor__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaxFloor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaxFloor::MaxFloor()\n"
    "    FIX::MaxFloor::MaxFloor(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaxFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaxFloor *arg1 = (FIX::MaxFloor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaxFloor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaxFloor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaxFloor" "', argument " "1"" of type '" "FIX::MaxFloor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaxFloor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MaxFloor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MaxFloor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeLocaleOfIssue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeLocaleOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeLocaleOfIssue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeLocaleOfIssue *)new FIX::DerivativeLocaleOfIssue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeLocaleOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeLocaleOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeLocaleOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeLocaleOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeLocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeLocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeLocaleOfIssue *)new FIX::DerivativeLocaleOfIssue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeLocaleOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeLocaleOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeLocaleOfIssue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeLocaleOfIssue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeLocaleOfIssue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeLocaleOfIssue::DerivativeLocaleOfIssue()\n"
    "    FIX::DerivativeLocaleOfIssue::DerivativeLocaleOfIssue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeLocaleOfIssue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeLocaleOfIssue *arg1 = (FIX::DerivativeLocaleOfIssue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeLocaleOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeLocaleOfIssue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeLocaleOfIssue" "', argument " "1"" of type '" "FIX::DerivativeLocaleOfIssue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeLocaleOfIssue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeLocaleOfIssue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeLocaleOfIssue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OptPayAmount__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OptPayAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OptPayAmount")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OptPayAmount *)new FIX::OptPayAmount();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OptPayAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptPayAmount__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OptPayAmount *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OptPayAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OptPayAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OptPayAmount" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OptPayAmount *)new FIX::OptPayAmount((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OptPayAmount, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OptPayAmount(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OptPayAmount__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OptPayAmount__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OptPayAmount'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OptPayAmount::OptPayAmount()\n"
    "    FIX::OptPayAmount::OptPayAmount(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OptPayAmount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OptPayAmount *arg1 = (FIX::OptPayAmount *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OptPayAmount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OptPayAmount, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptPayAmount" "', argument " "1"" of type '" "FIX::OptPayAmount *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OptPayAmount * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OptPayAmount_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OptPayAmount, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingStipType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingStipType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingStipType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingStipType *)new FIX::UnderlyingStipType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingStipType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStipType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingStipType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingStipType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingStipType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingStipType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingStipType *)new FIX::UnderlyingStipType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingStipType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingStipType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingStipType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingStipType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingStipType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingStipType::UnderlyingStipType()\n"
    "    FIX::UnderlyingStipType::UnderlyingStipType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingStipType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingStipType *arg1 = (FIX::UnderlyingStipType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingStipType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingStipType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingStipType" "', argument " "1"" of type '" "FIX::UnderlyingStipType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingStipType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingStipType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingStipType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Rule80A__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Rule80A *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Rule80A")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Rule80A *)new FIX::Rule80A();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Rule80A, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Rule80A__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Rule80A *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Rule80A",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rule80A" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rule80A" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Rule80A *)new FIX::Rule80A((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Rule80A, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Rule80A(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Rule80A__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Rule80A__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Rule80A'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Rule80A::Rule80A()\n"
    "    FIX::Rule80A::Rule80A(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Rule80A(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Rule80A *arg1 = (FIX::Rule80A *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Rule80A",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Rule80A, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rule80A" "', argument " "1"" of type '" "FIX::Rule80A *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Rule80A * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Rule80A_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Rule80A, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TotNoStrikes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoStrikes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TotNoStrikes")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoStrikes *)new FIX::TotNoStrikes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoStrikes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoStrikes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TotNoStrikes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TotNoStrikes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TotNoStrikes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TotNoStrikes" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TotNoStrikes *)new FIX::TotNoStrikes((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TotNoStrikes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TotNoStrikes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TotNoStrikes__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TotNoStrikes__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TotNoStrikes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TotNoStrikes::TotNoStrikes()\n"
    "    FIX::TotNoStrikes::TotNoStrikes(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TotNoStrikes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TotNoStrikes *arg1 = (FIX::TotNoStrikes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TotNoStrikes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TotNoStrikes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TotNoStrikes" "', argument " "1"" of type '" "FIX::TotNoStrikes *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TotNoStrikes * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TotNoStrikes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TotNoStrikes, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CorporateAction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CorporateAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CorporateAction")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CorporateAction *)new FIX::CorporateAction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CorporateAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CorporateAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLECHARVALUE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CorporateAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CorporateAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MULTIPLECHARVALUE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CorporateAction" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CorporateAction" "', argument " "1"" of type '" "FIX::MULTIPLECHARVALUE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLECHARVALUE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CorporateAction *)new FIX::CorporateAction((FIX::MULTIPLECHARVALUE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CorporateAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CorporateAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CorporateAction__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MULTIPLECHARVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CorporateAction__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CorporateAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CorporateAction::CorporateAction()\n"
    "    FIX::CorporateAction::CorporateAction(FIX::MULTIPLECHARVALUE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CorporateAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CorporateAction *arg1 = (FIX::CorporateAction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CorporateAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CorporateAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CorporateAction" "', argument " "1"" of type '" "FIX::CorporateAction *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CorporateAction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CorporateAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CorporateAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TerminationType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TerminationType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TerminationType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TerminationType *)new FIX::TerminationType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TerminationType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TerminationType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TerminationType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TerminationType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TerminationType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TerminationType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TerminationType *)new FIX::TerminationType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TerminationType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TerminationType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TerminationType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TerminationType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TerminationType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TerminationType::TerminationType()\n"
    "    FIX::TerminationType::TerminationType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TerminationType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TerminationType *arg1 = (FIX::TerminationType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TerminationType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TerminationType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TerminationType" "', argument " "1"" of type '" "FIX::TerminationType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TerminationType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TerminationType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TerminationType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegCouponRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCouponRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegCouponRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCouponRate *)new FIX::LegCouponRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCouponRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCouponRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegCouponRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegCouponRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegCouponRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCouponRate *)new FIX::LegCouponRate((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCouponRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCouponRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegCouponRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCouponRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegCouponRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegCouponRate::LegCouponRate()\n"
    "    FIX::LegCouponRate::LegCouponRate(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegCouponRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCouponRate *arg1 = (FIX::LegCouponRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegCouponRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegCouponRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegCouponRate" "', argument " "1"" of type '" "FIX::LegCouponRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegCouponRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegCouponRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegCouponRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PosMaintAction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosMaintAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PosMaintAction")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosMaintAction *)new FIX::PosMaintAction();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosMaintAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintAction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PosMaintAction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PosMaintAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PosMaintAction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PosMaintAction" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosMaintAction *)new FIX::PosMaintAction((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosMaintAction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosMaintAction(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PosMaintAction__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosMaintAction__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PosMaintAction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PosMaintAction::PosMaintAction()\n"
    "    FIX::PosMaintAction::PosMaintAction(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PosMaintAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosMaintAction *arg1 = (FIX::PosMaintAction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PosMaintAction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PosMaintAction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PosMaintAction" "', argument " "1"" of type '" "FIX::PosMaintAction *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PosMaintAction * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PosMaintAction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PosMaintAction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoSecurityTypes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSecurityTypes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoSecurityTypes")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSecurityTypes *)new FIX::NoSecurityTypes();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSecurityTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSecurityTypes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoSecurityTypes *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoSecurityTypes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoSecurityTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoSecurityTypes" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoSecurityTypes *)new FIX::NoSecurityTypes((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoSecurityTypes, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoSecurityTypes(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoSecurityTypes__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoSecurityTypes__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoSecurityTypes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoSecurityTypes::NoSecurityTypes()\n"
    "    FIX::NoSecurityTypes::NoSecurityTypes(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoSecurityTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoSecurityTypes *arg1 = (FIX::NoSecurityTypes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoSecurityTypes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoSecurityTypes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoSecurityTypes" "', argument " "1"" of type '" "FIX::NoSecurityTypes *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoSecurityTypes * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoSecurityTypes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoSecurityTypes, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ComplexEventPriceTimeType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventPriceTimeType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ComplexEventPriceTimeType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventPriceTimeType *)new FIX::ComplexEventPriceTimeType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventPriceTimeType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPriceTimeType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ComplexEventPriceTimeType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ComplexEventPriceTimeType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexEventPriceTimeType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplexEventPriceTimeType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventPriceTimeType *)new FIX::ComplexEventPriceTimeType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventPriceTimeType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventPriceTimeType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ComplexEventPriceTimeType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventPriceTimeType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ComplexEventPriceTimeType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ComplexEventPriceTimeType::ComplexEventPriceTimeType()\n"
    "    FIX::ComplexEventPriceTimeType::ComplexEventPriceTimeType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ComplexEventPriceTimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventPriceTimeType *arg1 = (FIX::ComplexEventPriceTimeType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ComplexEventPriceTimeType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ComplexEventPriceTimeType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComplexEventPriceTimeType" "', argument " "1"" of type '" "FIX::ComplexEventPriceTimeType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ComplexEventPriceTimeType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ComplexEventPriceTimeType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ComplexEventPriceTimeType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LastSwapPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastSwapPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LastSwapPoints")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastSwapPoints *)new FIX::LastSwapPoints();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastSwapPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastSwapPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICEOFFSET *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LastSwapPoints *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LastSwapPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICEOFFSET,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LastSwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LastSwapPoints" "', argument " "1"" of type '" "FIX::PRICEOFFSET const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICEOFFSET * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LastSwapPoints *)new FIX::LastSwapPoints((FIX::PRICEOFFSET const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LastSwapPoints, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LastSwapPoints(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LastSwapPoints__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICEOFFSET, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LastSwapPoints__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LastSwapPoints'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LastSwapPoints::LastSwapPoints()\n"
    "    FIX::LastSwapPoints::LastSwapPoints(FIX::PRICEOFFSET const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LastSwapPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LastSwapPoints *arg1 = (FIX::LastSwapPoints *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LastSwapPoints",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LastSwapPoints, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LastSwapPoints" "', argument " "1"" of type '" "FIX::LastSwapPoints *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LastSwapPoints * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LastSwapPoints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LastSwapPoints, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingFXRateCalc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingFXRateCalc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingFXRateCalc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingFXRateCalc *)new FIX::UnderlyingFXRateCalc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingFXRateCalc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFXRateCalc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingFXRateCalc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingFXRateCalc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingFXRateCalc" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingFXRateCalc" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingFXRateCalc *)new FIX::UnderlyingFXRateCalc((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingFXRateCalc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingFXRateCalc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingFXRateCalc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingFXRateCalc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingFXRateCalc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingFXRateCalc::UnderlyingFXRateCalc()\n"
    "    FIX::UnderlyingFXRateCalc::UnderlyingFXRateCalc(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingFXRateCalc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingFXRateCalc *arg1 = (FIX::UnderlyingFXRateCalc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingFXRateCalc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingFXRateCalc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingFXRateCalc" "', argument " "1"" of type '" "FIX::UnderlyingFXRateCalc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingFXRateCalc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingFXRateCalc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingFXRateCalc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ListStatusText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListStatusText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ListStatusText")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListStatusText *)new FIX::ListStatusText();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListStatusText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListStatusText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ListStatusText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ListStatusText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListStatusText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListStatusText" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListStatusText *)new FIX::ListStatusText((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListStatusText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListStatusText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ListStatusText__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListStatusText__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ListStatusText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ListStatusText::ListStatusText()\n"
    "    FIX::ListStatusText::ListStatusText(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListStatusText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListStatusText *arg1 = (FIX::ListStatusText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ListStatusText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ListStatusText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListStatusText" "', argument " "1"" of type '" "FIX::ListStatusText *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ListStatusText * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListStatusText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ListStatusText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OddLot__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OddLot *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OddLot")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OddLot *)new FIX::OddLot();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OddLot, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OddLot__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OddLot *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OddLot",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OddLot" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OddLot" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OddLot *)new FIX::OddLot((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OddLot, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OddLot(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OddLot__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OddLot__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OddLot'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OddLot::OddLot()\n"
    "    FIX::OddLot::OddLot(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OddLot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OddLot *arg1 = (FIX::OddLot *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OddLot",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OddLot, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OddLot" "', argument " "1"" of type '" "FIX::OddLot *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OddLot * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OddLot_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OddLot, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BookingUnit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BookingUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BookingUnit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BookingUnit *)new FIX::BookingUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BookingUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BookingUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BookingUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BookingUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BookingUnit" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BookingUnit" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BookingUnit *)new FIX::BookingUnit((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BookingUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BookingUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BookingUnit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BookingUnit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BookingUnit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BookingUnit::BookingUnit()\n"
    "    FIX::BookingUnit::BookingUnit(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BookingUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BookingUnit *arg1 = (FIX::BookingUnit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BookingUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BookingUnit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BookingUnit" "', argument " "1"" of type '" "FIX::BookingUnit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BookingUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BookingUnit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BookingUnit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegAllocAcctIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegAllocAcctIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegAllocAcctIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegAllocAcctIDSource *)new FIX::LegAllocAcctIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegAllocAcctIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocAcctIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegAllocAcctIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegAllocAcctIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegAllocAcctIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegAllocAcctIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegAllocAcctIDSource *)new FIX::LegAllocAcctIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegAllocAcctIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocAcctIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegAllocAcctIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegAllocAcctIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegAllocAcctIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegAllocAcctIDSource::LegAllocAcctIDSource()\n"
    "    FIX::LegAllocAcctIDSource::LegAllocAcctIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegAllocAcctIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegAllocAcctIDSource *arg1 = (FIX::LegAllocAcctIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegAllocAcctIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegAllocAcctIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegAllocAcctIDSource" "', argument " "1"" of type '" "FIX::LegAllocAcctIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegAllocAcctIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegAllocAcctIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegAllocAcctIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OnBehalfOfSendingTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OnBehalfOfSendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OnBehalfOfSendingTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OnBehalfOfSendingTime *)new FIX::OnBehalfOfSendingTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OnBehalfOfSendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfSendingTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OnBehalfOfSendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OnBehalfOfSendingTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OnBehalfOfSendingTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OnBehalfOfSendingTime *)new FIX::OnBehalfOfSendingTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OnBehalfOfSendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfSendingTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OnBehalfOfSendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OnBehalfOfSendingTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OnBehalfOfSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OnBehalfOfSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OnBehalfOfSendingTime *)new FIX::OnBehalfOfSendingTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OnBehalfOfSendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfSendingTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::OnBehalfOfSendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_OnBehalfOfSendingTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OnBehalfOfSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OnBehalfOfSendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OnBehalfOfSendingTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OnBehalfOfSendingTime *)new FIX::OnBehalfOfSendingTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OnBehalfOfSendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OnBehalfOfSendingTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OnBehalfOfSendingTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OnBehalfOfSendingTime__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_OnBehalfOfSendingTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_OnBehalfOfSendingTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OnBehalfOfSendingTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OnBehalfOfSendingTime::OnBehalfOfSendingTime()\n"
    "    FIX::OnBehalfOfSendingTime::OnBehalfOfSendingTime(bool)\n"
    "    FIX::OnBehalfOfSendingTime::OnBehalfOfSendingTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::OnBehalfOfSendingTime::OnBehalfOfSendingTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OnBehalfOfSendingTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OnBehalfOfSendingTime *arg1 = (FIX::OnBehalfOfSendingTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OnBehalfOfSendingTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OnBehalfOfSendingTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OnBehalfOfSendingTime" "', argument " "1"" of type '" "FIX::OnBehalfOfSendingTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OnBehalfOfSendingTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OnBehalfOfSendingTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OnBehalfOfSendingTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AllocStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AllocStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocStatus *)new FIX::AllocStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AllocStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AllocStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AllocStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AllocStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AllocStatus *)new FIX::AllocStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AllocStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AllocStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AllocStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AllocStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AllocStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AllocStatus::AllocStatus()\n"
    "    FIX::AllocStatus::AllocStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AllocStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AllocStatus *arg1 = (FIX::AllocStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AllocStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AllocStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AllocStatus" "', argument " "1"" of type '" "FIX::AllocStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AllocStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AllocStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AllocStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ReferencePage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ReferencePage *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ReferencePage")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ReferencePage *)new FIX::ReferencePage();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ReferencePage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReferencePage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ReferencePage *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ReferencePage",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ReferencePage" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ReferencePage" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ReferencePage *)new FIX::ReferencePage((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ReferencePage, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReferencePage(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ReferencePage__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ReferencePage__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ReferencePage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ReferencePage::ReferencePage()\n"
    "    FIX::ReferencePage::ReferencePage(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ReferencePage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ReferencePage *arg1 = (FIX::ReferencePage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ReferencePage",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ReferencePage, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReferencePage" "', argument " "1"" of type '" "FIX::ReferencePage *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ReferencePage * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ReferencePage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ReferencePage, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeExerciseStyle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeExerciseStyle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeExerciseStyle")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeExerciseStyle *)new FIX::DerivativeExerciseStyle();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeExerciseStyle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeExerciseStyle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeExerciseStyle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeExerciseStyle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeExerciseStyle" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeExerciseStyle" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeExerciseStyle *)new FIX::DerivativeExerciseStyle((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeExerciseStyle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeExerciseStyle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeExerciseStyle__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeExerciseStyle__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeExerciseStyle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeExerciseStyle::DerivativeExerciseStyle()\n"
    "    FIX::DerivativeExerciseStyle::DerivativeExerciseStyle(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeExerciseStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeExerciseStyle *arg1 = (FIX::DerivativeExerciseStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeExerciseStyle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeExerciseStyle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeExerciseStyle" "', argument " "1"" of type '" "FIX::DerivativeExerciseStyle *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeExerciseStyle * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeExerciseStyle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeExerciseStyle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ApplBegSeqNum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplBegSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplBegSeqNum")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplBegSeqNum *)new FIX::ApplBegSeqNum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplBegSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplBegSeqNum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SEQNUM *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplBegSeqNum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplBegSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SEQNUM,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplBegSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplBegSeqNum" "', argument " "1"" of type '" "FIX::SEQNUM const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SEQNUM * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplBegSeqNum *)new FIX::ApplBegSeqNum((FIX::SEQNUM const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplBegSeqNum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplBegSeqNum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplBegSeqNum__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SEQNUM, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplBegSeqNum__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplBegSeqNum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplBegSeqNum::ApplBegSeqNum()\n"
    "    FIX::ApplBegSeqNum::ApplBegSeqNum(FIX::SEQNUM const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplBegSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplBegSeqNum *arg1 = (FIX::ApplBegSeqNum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplBegSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplBegSeqNum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplBegSeqNum" "', argument " "1"" of type '" "FIX::ApplBegSeqNum *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplBegSeqNum * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ApplBegSeqNum_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ApplBegSeqNum, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CollRptID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollRptID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CollRptID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollRptID *)new FIX::CollRptID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollRptID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollRptID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CollRptID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CollRptID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CollRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CollRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CollRptID *)new FIX::CollRptID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CollRptID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CollRptID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CollRptID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CollRptID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CollRptID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CollRptID::CollRptID()\n"
    "    FIX::CollRptID::CollRptID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CollRptID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CollRptID *arg1 = (FIX::CollRptID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CollRptID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CollRptID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CollRptID" "', argument " "1"" of type '" "FIX::CollRptID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CollRptID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CollRptID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CollRptID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_IncTaxInd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncTaxInd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IncTaxInd")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IncTaxInd *)new FIX::IncTaxInd();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncTaxInd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncTaxInd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IncTaxInd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IncTaxInd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IncTaxInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IncTaxInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IncTaxInd *)new FIX::IncTaxInd((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IncTaxInd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IncTaxInd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IncTaxInd__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IncTaxInd__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IncTaxInd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IncTaxInd::IncTaxInd()\n"
    "    FIX::IncTaxInd::IncTaxInd(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IncTaxInd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IncTaxInd *arg1 = (FIX::IncTaxInd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IncTaxInd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IncTaxInd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IncTaxInd" "', argument " "1"" of type '" "FIX::IncTaxInd *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IncTaxInd * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IncTaxInd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__IncTaxInd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoBidDescriptors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoBidDescriptors *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoBidDescriptors")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoBidDescriptors *)new FIX::NoBidDescriptors();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoBidDescriptors, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoBidDescriptors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoBidDescriptors *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoBidDescriptors",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoBidDescriptors" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoBidDescriptors" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoBidDescriptors *)new FIX::NoBidDescriptors((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoBidDescriptors, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoBidDescriptors(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoBidDescriptors__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoBidDescriptors__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoBidDescriptors'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoBidDescriptors::NoBidDescriptors()\n"
    "    FIX::NoBidDescriptors::NoBidDescriptors(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoBidDescriptors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoBidDescriptors *arg1 = (FIX::NoBidDescriptors *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoBidDescriptors",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoBidDescriptors, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoBidDescriptors" "', argument " "1"" of type '" "FIX::NoBidDescriptors *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoBidDescriptors * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoBidDescriptors_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoBidDescriptors, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegCouponPaymentDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCouponPaymentDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegCouponPaymentDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCouponPaymentDate *)new FIX::LegCouponPaymentDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCouponPaymentDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCouponPaymentDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegCouponPaymentDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegCouponPaymentDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegCouponPaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegCouponPaymentDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegCouponPaymentDate *)new FIX::LegCouponPaymentDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegCouponPaymentDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegCouponPaymentDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegCouponPaymentDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegCouponPaymentDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegCouponPaymentDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegCouponPaymentDate::LegCouponPaymentDate()\n"
    "    FIX::LegCouponPaymentDate::LegCouponPaymentDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegCouponPaymentDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegCouponPaymentDate *arg1 = (FIX::LegCouponPaymentDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegCouponPaymentDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegCouponPaymentDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegCouponPaymentDate" "', argument " "1"" of type '" "FIX::LegCouponPaymentDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegCouponPaymentDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegCouponPaymentDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegCouponPaymentDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoUnderlyingLegSecurityAltID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoUnderlyingLegSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoUnderlyingLegSecurityAltID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoUnderlyingLegSecurityAltID *)new FIX::NoUnderlyingLegSecurityAltID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoUnderlyingLegSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingLegSecurityAltID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoUnderlyingLegSecurityAltID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoUnderlyingLegSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoUnderlyingLegSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoUnderlyingLegSecurityAltID" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoUnderlyingLegSecurityAltID *)new FIX::NoUnderlyingLegSecurityAltID((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoUnderlyingLegSecurityAltID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoUnderlyingLegSecurityAltID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoUnderlyingLegSecurityAltID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoUnderlyingLegSecurityAltID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoUnderlyingLegSecurityAltID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoUnderlyingLegSecurityAltID::NoUnderlyingLegSecurityAltID()\n"
    "    FIX::NoUnderlyingLegSecurityAltID::NoUnderlyingLegSecurityAltID(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoUnderlyingLegSecurityAltID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoUnderlyingLegSecurityAltID *arg1 = (FIX::NoUnderlyingLegSecurityAltID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoUnderlyingLegSecurityAltID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoUnderlyingLegSecurityAltID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoUnderlyingLegSecurityAltID" "', argument " "1"" of type '" "FIX::NoUnderlyingLegSecurityAltID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoUnderlyingLegSecurityAltID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoUnderlyingLegSecurityAltID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoUnderlyingLegSecurityAltID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ReversalIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ReversalIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ReversalIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ReversalIndicator *)new FIX::ReversalIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ReversalIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReversalIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ReversalIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ReversalIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ReversalIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ReversalIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ReversalIndicator *)new FIX::ReversalIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ReversalIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReversalIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ReversalIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ReversalIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ReversalIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ReversalIndicator::ReversalIndicator()\n"
    "    FIX::ReversalIndicator::ReversalIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ReversalIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ReversalIndicator *arg1 = (FIX::ReversalIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ReversalIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ReversalIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReversalIndicator" "', argument " "1"" of type '" "FIX::ReversalIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ReversalIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ReversalIndicator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ReversalIndicator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CheckSum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CheckSum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CheckSum")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CheckSum *)new FIX::CheckSum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CheckSum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CheckSum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CheckSum *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CheckSum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CheckSum" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CheckSum" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CheckSum *)new FIX::CheckSum((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CheckSum, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CheckSum(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CheckSum__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CheckSum__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CheckSum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CheckSum::CheckSum()\n"
    "    FIX::CheckSum::CheckSum(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CheckSum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CheckSum *arg1 = (FIX::CheckSum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CheckSum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CheckSum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CheckSum" "', argument " "1"" of type '" "FIX::CheckSum *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CheckSum * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CheckSum_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CheckSum, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TargetSubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TargetSubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetSubID *)new FIX::TargetSubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetSubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TargetSubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TargetSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TargetSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TargetSubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetSubID *)new FIX::TargetSubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetSubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetSubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TargetSubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetSubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TargetSubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TargetSubID::TargetSubID()\n"
    "    FIX::TargetSubID::TargetSubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TargetSubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetSubID *arg1 = (FIX::TargetSubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TargetSubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TargetSubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TargetSubID" "', argument " "1"" of type '" "FIX::TargetSubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TargetSubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TargetSubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TargetSubID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PosReqStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosReqStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PosReqStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosReqStatus *)new FIX::PosReqStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosReqStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PosReqStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PosReqStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PosReqStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PosReqStatus" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PosReqStatus *)new FIX::PosReqStatus((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PosReqStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PosReqStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PosReqStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PosReqStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PosReqStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PosReqStatus::PosReqStatus()\n"
    "    FIX::PosReqStatus::PosReqStatus(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PosReqStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PosReqStatus *arg1 = (FIX::PosReqStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PosReqStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PosReqStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PosReqStatus" "', argument " "1"" of type '" "FIX::PosReqStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PosReqStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PosReqStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PosReqStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PriorityIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriorityIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PriorityIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriorityIndicator *)new FIX::PriorityIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriorityIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriorityIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::PriorityIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PriorityIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PriorityIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PriorityIndicator" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::PriorityIndicator *)new FIX::PriorityIndicator((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__PriorityIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PriorityIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_PriorityIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PriorityIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PriorityIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::PriorityIndicator::PriorityIndicator()\n"
    "    FIX::PriorityIndicator::PriorityIndicator(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PriorityIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PriorityIndicator *arg1 = (FIX::PriorityIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PriorityIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__PriorityIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PriorityIndicator" "', argument " "1"" of type '" "FIX::PriorityIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::PriorityIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PriorityIndicator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__PriorityIndicator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingLegCFICode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegCFICode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegCFICode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegCFICode *)new FIX::UnderlyingLegCFICode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegCFICode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegCFICode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegCFICode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegCFICode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegCFICode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegCFICode *)new FIX::UnderlyingLegCFICode((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegCFICode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegCFICode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegCFICode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegCFICode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegCFICode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegCFICode::UnderlyingLegCFICode()\n"
    "    FIX::UnderlyingLegCFICode::UnderlyingLegCFICode(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegCFICode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegCFICode *arg1 = (FIX::UnderlyingLegCFICode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegCFICode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegCFICode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegCFICode" "', argument " "1"" of type '" "FIX::UnderlyingLegCFICode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegCFICode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingLegCFICode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingLegCFICode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeTimeUnit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeTimeUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeTimeUnit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeTimeUnit *)new FIX::DerivativeTimeUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeTimeUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeTimeUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeTimeUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeTimeUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeTimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeTimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeTimeUnit *)new FIX::DerivativeTimeUnit((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeTimeUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeTimeUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeTimeUnit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeTimeUnit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeTimeUnit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeTimeUnit::DerivativeTimeUnit()\n"
    "    FIX::DerivativeTimeUnit::DerivativeTimeUnit(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeTimeUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeTimeUnit *arg1 = (FIX::DerivativeTimeUnit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeTimeUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeTimeUnit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeTimeUnit" "', argument " "1"" of type '" "FIX::DerivativeTimeUnit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeTimeUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeTimeUnit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeTimeUnit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoNested3PartyIDs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNested3PartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoNested3PartyIDs")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNested3PartyIDs *)new FIX::NoNested3PartyIDs();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNested3PartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested3PartyIDs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoNested3PartyIDs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoNested3PartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoNested3PartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoNested3PartyIDs" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoNested3PartyIDs *)new FIX::NoNested3PartyIDs((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoNested3PartyIDs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoNested3PartyIDs(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoNested3PartyIDs__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoNested3PartyIDs__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoNested3PartyIDs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoNested3PartyIDs::NoNested3PartyIDs()\n"
    "    FIX::NoNested3PartyIDs::NoNested3PartyIDs(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoNested3PartyIDs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoNested3PartyIDs *arg1 = (FIX::NoNested3PartyIDs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoNested3PartyIDs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoNested3PartyIDs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoNested3PartyIDs" "', argument " "1"" of type '" "FIX::NoNested3PartyIDs *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoNested3PartyIDs * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoNested3PartyIDs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoNested3PartyIDs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LiquidityPctHigh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LiquidityPctHigh *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LiquidityPctHigh")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LiquidityPctHigh *)new FIX::LiquidityPctHigh();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LiquidityPctHigh, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityPctHigh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LiquidityPctHigh *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LiquidityPctHigh",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LiquidityPctHigh" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LiquidityPctHigh" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LiquidityPctHigh *)new FIX::LiquidityPctHigh((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LiquidityPctHigh, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LiquidityPctHigh(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LiquidityPctHigh__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LiquidityPctHigh__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LiquidityPctHigh'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LiquidityPctHigh::LiquidityPctHigh()\n"
    "    FIX::LiquidityPctHigh::LiquidityPctHigh(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LiquidityPctHigh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LiquidityPctHigh *arg1 = (FIX::LiquidityPctHigh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LiquidityPctHigh",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LiquidityPctHigh, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LiquidityPctHigh" "', argument " "1"" of type '" "FIX::LiquidityPctHigh *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LiquidityPctHigh * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LiquidityPctHigh_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LiquidityPctHigh, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MoneyLaunderingStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MoneyLaunderingStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MoneyLaunderingStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MoneyLaunderingStatus *)new FIX::MoneyLaunderingStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MoneyLaunderingStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoneyLaunderingStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MoneyLaunderingStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MoneyLaunderingStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoneyLaunderingStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MoneyLaunderingStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MoneyLaunderingStatus *)new FIX::MoneyLaunderingStatus((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MoneyLaunderingStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoneyLaunderingStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MoneyLaunderingStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MoneyLaunderingStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MoneyLaunderingStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MoneyLaunderingStatus::MoneyLaunderingStatus()\n"
    "    FIX::MoneyLaunderingStatus::MoneyLaunderingStatus(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MoneyLaunderingStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MoneyLaunderingStatus *arg1 = (FIX::MoneyLaunderingStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MoneyLaunderingStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MoneyLaunderingStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MoneyLaunderingStatus" "', argument " "1"" of type '" "FIX::MoneyLaunderingStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MoneyLaunderingStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MoneyLaunderingStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MoneyLaunderingStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Nested4PartySubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested4PartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested4PartySubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested4PartySubID *)new FIX::Nested4PartySubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested4PartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested4PartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested4PartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested4PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested4PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested4PartySubID *)new FIX::Nested4PartySubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested4PartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested4PartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested4PartySubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested4PartySubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested4PartySubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested4PartySubID::Nested4PartySubID()\n"
    "    FIX::Nested4PartySubID::Nested4PartySubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested4PartySubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested4PartySubID *arg1 = (FIX::Nested4PartySubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested4PartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested4PartySubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested4PartySubID" "', argument " "1"" of type '" "FIX::Nested4PartySubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested4PartySubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Nested4PartySubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Nested4PartySubID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeSecurityExchange__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityExchange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSecurityExchange")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityExchange *)new FIX::DerivativeSecurityExchange();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityExchange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityExchange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EXCHANGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSecurityExchange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSecurityExchange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__EXCHANGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSecurityExchange" "', argument " "1"" of type '" "FIX::EXCHANGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::EXCHANGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityExchange *)new FIX::DerivativeSecurityExchange((FIX::EXCHANGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityExchange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityExchange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSecurityExchange__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__EXCHANGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityExchange__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSecurityExchange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSecurityExchange::DerivativeSecurityExchange()\n"
    "    FIX::DerivativeSecurityExchange::DerivativeSecurityExchange(FIX::EXCHANGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSecurityExchange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityExchange *arg1 = (FIX::DerivativeSecurityExchange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSecurityExchange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSecurityExchange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSecurityExchange" "', argument " "1"" of type '" "FIX::DerivativeSecurityExchange *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSecurityExchange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeSecurityExchange_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeSecurityExchange, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LotType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LotType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LotType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LotType *)new FIX::LotType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LotType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LotType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LotType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LotType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LotType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LotType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LotType *)new FIX::LotType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LotType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LotType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LotType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LotType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LotType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LotType::LotType()\n"
    "    FIX::LotType::LotType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LotType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LotType *arg1 = (FIX::LotType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LotType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LotType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LotType" "', argument " "1"" of type '" "FIX::LotType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LotType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LotType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LotType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ContIntRptID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContIntRptID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ContIntRptID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContIntRptID *)new FIX::ContIntRptID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContIntRptID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContIntRptID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ContIntRptID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ContIntRptID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContIntRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContIntRptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ContIntRptID *)new FIX::ContIntRptID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ContIntRptID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ContIntRptID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ContIntRptID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ContIntRptID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContIntRptID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ContIntRptID::ContIntRptID()\n"
    "    FIX::ContIntRptID::ContIntRptID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ContIntRptID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ContIntRptID *arg1 = (FIX::ContIntRptID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ContIntRptID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ContIntRptID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContIntRptID" "', argument " "1"" of type '" "FIX::ContIntRptID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ContIntRptID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ContIntRptID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ContIntRptID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_QuoteCondition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteCondition *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteCondition")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteCondition *)new FIX::QuoteCondition();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteCondition, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteCondition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MULTIPLESTRINGVALUE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteCondition *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteCondition",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteCondition" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteCondition" "', argument " "1"" of type '" "FIX::MULTIPLESTRINGVALUE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::MULTIPLESTRINGVALUE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteCondition *)new FIX::QuoteCondition((FIX::MULTIPLESTRINGVALUE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteCondition, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteCondition(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteCondition__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__MULTIPLESTRINGVALUE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteCondition__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteCondition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteCondition::QuoteCondition()\n"
    "    FIX::QuoteCondition::QuoteCondition(FIX::MULTIPLESTRINGVALUE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteCondition *arg1 = (FIX::QuoteCondition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteCondition",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteCondition, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteCondition" "', argument " "1"" of type '" "FIX::QuoteCondition *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteCondition * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteCondition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__QuoteCondition, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ComplexEventStartTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventStartTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ComplexEventStartTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventStartTime *)new FIX::ComplexEventStartTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventStartTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventStartTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMEONLY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ComplexEventStartTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ComplexEventStartTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMEONLY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexEventStartTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplexEventStartTime" "', argument " "1"" of type '" "FIX::UTCTIMEONLY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMEONLY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventStartTime *)new FIX::ComplexEventStartTime((FIX::UTCTIMEONLY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventStartTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventStartTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ComplexEventStartTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMEONLY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventStartTime__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ComplexEventStartTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ComplexEventStartTime::ComplexEventStartTime()\n"
    "    FIX::ComplexEventStartTime::ComplexEventStartTime(FIX::UTCTIMEONLY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ComplexEventStartTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventStartTime *arg1 = (FIX::ComplexEventStartTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ComplexEventStartTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ComplexEventStartTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComplexEventStartTime" "', argument " "1"" of type '" "FIX::ComplexEventStartTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ComplexEventStartTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ComplexEventStartTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ComplexEventStartTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoComplexEvents__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoComplexEvents *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoComplexEvents")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoComplexEvents *)new FIX::NoComplexEvents();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoComplexEvents, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoComplexEvents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoComplexEvents *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoComplexEvents",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoComplexEvents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoComplexEvents" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoComplexEvents *)new FIX::NoComplexEvents((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoComplexEvents, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoComplexEvents(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoComplexEvents__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoComplexEvents__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoComplexEvents'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoComplexEvents::NoComplexEvents()\n"
    "    FIX::NoComplexEvents::NoComplexEvents(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoComplexEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoComplexEvents *arg1 = (FIX::NoComplexEvents *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoComplexEvents",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoComplexEvents, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoComplexEvents" "', argument " "1"" of type '" "FIX::NoComplexEvents *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoComplexEvents * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoComplexEvents_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoComplexEvents, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeContractMultiplier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeContractMultiplier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeContractMultiplier")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeContractMultiplier *)new FIX::DerivativeContractMultiplier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeContractMultiplier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeContractMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeContractMultiplier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeContractMultiplier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeContractMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeContractMultiplier *)new FIX::DerivativeContractMultiplier((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeContractMultiplier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeContractMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeContractMultiplier__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeContractMultiplier__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeContractMultiplier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeContractMultiplier::DerivativeContractMultiplier()\n"
    "    FIX::DerivativeContractMultiplier::DerivativeContractMultiplier(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeContractMultiplier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeContractMultiplier *arg1 = (FIX::DerivativeContractMultiplier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeContractMultiplier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeContractMultiplier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeContractMultiplier" "', argument " "1"" of type '" "FIX::DerivativeContractMultiplier *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeContractMultiplier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeContractMultiplier_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeContractMultiplier, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeSecurityStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeSecurityStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityStatus *)new FIX::DerivativeSecurityStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeSecurityStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeSecurityStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeSecurityStatus" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeSecurityStatus" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeSecurityStatus *)new FIX::DerivativeSecurityStatus((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeSecurityStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeSecurityStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeSecurityStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeSecurityStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeSecurityStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeSecurityStatus::DerivativeSecurityStatus()\n"
    "    FIX::DerivativeSecurityStatus::DerivativeSecurityStatus(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeSecurityStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeSecurityStatus *arg1 = (FIX::DerivativeSecurityStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeSecurityStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeSecurityStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeSecurityStatus" "', argument " "1"" of type '" "FIX::DerivativeSecurityStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeSecurityStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeSecurityStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeSecurityStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeProductComplex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeProductComplex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeProductComplex")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeProductComplex *)new FIX::DerivativeProductComplex();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeProductComplex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeProductComplex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeProductComplex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeProductComplex",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeProductComplex" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeProductComplex" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeProductComplex *)new FIX::DerivativeProductComplex((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeProductComplex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeProductComplex(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeProductComplex__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeProductComplex__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeProductComplex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeProductComplex::DerivativeProductComplex()\n"
    "    FIX::DerivativeProductComplex::DerivativeProductComplex(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeProductComplex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeProductComplex *arg1 = (FIX::DerivativeProductComplex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeProductComplex",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeProductComplex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeProductComplex" "', argument " "1"" of type '" "FIX::DerivativeProductComplex *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeProductComplex * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeProductComplex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeProductComplex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TriggerSymbol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerSymbol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TriggerSymbol")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerSymbol *)new FIX::TriggerSymbol();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerSymbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSymbol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TriggerSymbol *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TriggerSymbol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TriggerSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TriggerSymbol" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TriggerSymbol *)new FIX::TriggerSymbol((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TriggerSymbol, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TriggerSymbol(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TriggerSymbol__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TriggerSymbol__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TriggerSymbol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TriggerSymbol::TriggerSymbol()\n"
    "    FIX::TriggerSymbol::TriggerSymbol(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TriggerSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TriggerSymbol *arg1 = (FIX::TriggerSymbol *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TriggerSymbol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TriggerSymbol, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TriggerSymbol" "', argument " "1"" of type '" "FIX::TriggerSymbol *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TriggerSymbol * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TriggerSymbol_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TriggerSymbol, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingLocaleOfIssue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLocaleOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLocaleOfIssue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLocaleOfIssue *)new FIX::UnderlyingLocaleOfIssue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLocaleOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLocaleOfIssue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLocaleOfIssue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLocaleOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLocaleOfIssue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLocaleOfIssue *)new FIX::UnderlyingLocaleOfIssue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLocaleOfIssue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLocaleOfIssue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLocaleOfIssue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLocaleOfIssue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLocaleOfIssue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLocaleOfIssue::UnderlyingLocaleOfIssue()\n"
    "    FIX::UnderlyingLocaleOfIssue::UnderlyingLocaleOfIssue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLocaleOfIssue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLocaleOfIssue *arg1 = (FIX::UnderlyingLocaleOfIssue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLocaleOfIssue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLocaleOfIssue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLocaleOfIssue" "', argument " "1"" of type '" "FIX::UnderlyingLocaleOfIssue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLocaleOfIssue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingLocaleOfIssue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingLocaleOfIssue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SendingTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SendingTime")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SendingTime *)new FIX::SendingTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SendingTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SendingTime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SendingTime" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SendingTime *)new FIX::SendingTime(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SendingTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SendingTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SendingTime *)new FIX::SendingTime((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SendingTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::SendingTime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_SendingTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SendingTime" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SendingTime" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SendingTime *)new FIX::SendingTime((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SendingTime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SendingTime(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SendingTime__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SendingTime__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_SendingTime__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SendingTime__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SendingTime'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SendingTime::SendingTime()\n"
    "    FIX::SendingTime::SendingTime(bool)\n"
    "    FIX::SendingTime::SendingTime(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::SendingTime::SendingTime(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SendingTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SendingTime *arg1 = (FIX::SendingTime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SendingTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SendingTime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SendingTime" "', argument " "1"" of type '" "FIX::SendingTime *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SendingTime * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SendingTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SendingTime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ComplexEventStartDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventStartDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ComplexEventStartDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventStartDate *)new FIX::ComplexEventStartDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventStartDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventStartDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ComplexEventStartDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ComplexEventStartDate",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ComplexEventStartDate" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventStartDate *)new FIX::ComplexEventStartDate(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventStartDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventStartDate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ComplexEventStartDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ComplexEventStartDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexEventStartDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplexEventStartDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventStartDate *)new FIX::ComplexEventStartDate((FIX::UTCTIMESTAMP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventStartDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventStartDate__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UTCTIMESTAMP *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::ComplexEventStartDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ComplexEventStartDate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__UTCTIMESTAMP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexEventStartDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ComplexEventStartDate" "', argument " "1"" of type '" "FIX::UTCTIMESTAMP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::UTCTIMESTAMP * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ComplexEventStartDate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ComplexEventStartDate *)new FIX::ComplexEventStartDate((FIX::UTCTIMESTAMP const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ComplexEventStartDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ComplexEventStartDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ComplexEventStartDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ComplexEventStartDate__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_ComplexEventStartDate__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__UTCTIMESTAMP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ComplexEventStartDate__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ComplexEventStartDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ComplexEventStartDate::ComplexEventStartDate()\n"
    "    FIX::ComplexEventStartDate::ComplexEventStartDate(bool)\n"
    "    FIX::ComplexEventStartDate::ComplexEventStartDate(FIX::UTCTIMESTAMP const &)\n"
    "    FIX::ComplexEventStartDate::ComplexEventStartDate(FIX::UTCTIMESTAMP const &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ComplexEventStartDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ComplexEventStartDate *arg1 = (FIX::ComplexEventStartDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ComplexEventStartDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ComplexEventStartDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ComplexEventStartDate" "', argument " "1"" of type '" "FIX::ComplexEventStartDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ComplexEventStartDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ComplexEventStartDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ComplexEventStartDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingRestructuringType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingRestructuringType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingRestructuringType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingRestructuringType *)new FIX::UnderlyingRestructuringType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingRestructuringType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRestructuringType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingRestructuringType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingRestructuringType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingRestructuringType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingRestructuringType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingRestructuringType *)new FIX::UnderlyingRestructuringType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingRestructuringType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingRestructuringType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingRestructuringType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingRestructuringType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingRestructuringType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingRestructuringType::UnderlyingRestructuringType()\n"
    "    FIX::UnderlyingRestructuringType::UnderlyingRestructuringType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingRestructuringType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingRestructuringType *arg1 = (FIX::UnderlyingRestructuringType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingRestructuringType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingRestructuringType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingRestructuringType" "', argument " "1"" of type '" "FIX::UnderlyingRestructuringType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingRestructuringType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingRestructuringType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingRestructuringType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegUnitOfMeasureQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegUnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegUnitOfMeasureQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegUnitOfMeasureQty *)new FIX::LegUnitOfMeasureQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegUnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegUnitOfMeasureQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegUnitOfMeasureQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegUnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegUnitOfMeasureQty *)new FIX::LegUnitOfMeasureQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegUnitOfMeasureQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegUnitOfMeasureQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegUnitOfMeasureQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegUnitOfMeasureQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegUnitOfMeasureQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegUnitOfMeasureQty::LegUnitOfMeasureQty()\n"
    "    FIX::LegUnitOfMeasureQty::LegUnitOfMeasureQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegUnitOfMeasureQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegUnitOfMeasureQty *arg1 = (FIX::LegUnitOfMeasureQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegUnitOfMeasureQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegUnitOfMeasureQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegUnitOfMeasureQty" "', argument " "1"" of type '" "FIX::LegUnitOfMeasureQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegUnitOfMeasureQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegUnitOfMeasureQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegUnitOfMeasureQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoTrdRegTimestamps__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTrdRegTimestamps *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoTrdRegTimestamps")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTrdRegTimestamps *)new FIX::NoTrdRegTimestamps();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTrdRegTimestamps, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTrdRegTimestamps__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoTrdRegTimestamps *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoTrdRegTimestamps",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoTrdRegTimestamps" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoTrdRegTimestamps" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoTrdRegTimestamps *)new FIX::NoTrdRegTimestamps((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoTrdRegTimestamps, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoTrdRegTimestamps(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoTrdRegTimestamps__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoTrdRegTimestamps__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoTrdRegTimestamps'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoTrdRegTimestamps::NoTrdRegTimestamps()\n"
    "    FIX::NoTrdRegTimestamps::NoTrdRegTimestamps(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoTrdRegTimestamps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoTrdRegTimestamps *arg1 = (FIX::NoTrdRegTimestamps *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoTrdRegTimestamps",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoTrdRegTimestamps, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoTrdRegTimestamps" "', argument " "1"" of type '" "FIX::NoTrdRegTimestamps *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoTrdRegTimestamps * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoTrdRegTimestamps_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoTrdRegTimestamps, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SendingDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SendingDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SendingDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SendingDate *)new FIX::SendingDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SendingDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SendingDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SendingDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SendingDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SendingDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SendingDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SendingDate *)new FIX::SendingDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SendingDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SendingDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SendingDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SendingDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SendingDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SendingDate::SendingDate()\n"
    "    FIX::SendingDate::SendingDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SendingDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SendingDate *arg1 = (FIX::SendingDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SendingDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SendingDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SendingDate" "', argument " "1"" of type '" "FIX::SendingDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SendingDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SendingDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SendingDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TimeToExpiration__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TimeToExpiration *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TimeToExpiration")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TimeToExpiration *)new FIX::TimeToExpiration();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TimeToExpiration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeToExpiration__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TimeToExpiration *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TimeToExpiration",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimeToExpiration" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimeToExpiration" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TimeToExpiration *)new FIX::TimeToExpiration((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TimeToExpiration, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeToExpiration(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TimeToExpiration__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TimeToExpiration__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TimeToExpiration'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TimeToExpiration::TimeToExpiration()\n"
    "    FIX::TimeToExpiration::TimeToExpiration(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TimeToExpiration(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TimeToExpiration *arg1 = (FIX::TimeToExpiration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TimeToExpiration",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TimeToExpiration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeToExpiration" "', argument " "1"" of type '" "FIX::TimeToExpiration *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TimeToExpiration * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TimeToExpiration_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TimeToExpiration, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegAllocQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegAllocQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegAllocQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegAllocQty *)new FIX::LegAllocQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegAllocQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegAllocQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegAllocQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegAllocQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegAllocQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegAllocQty *)new FIX::LegAllocQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegAllocQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegAllocQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegAllocQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegAllocQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegAllocQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegAllocQty::LegAllocQty()\n"
    "    FIX::LegAllocQty::LegAllocQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegAllocQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegAllocQty *arg1 = (FIX::LegAllocQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegAllocQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegAllocQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegAllocQty" "', argument " "1"" of type '" "FIX::LegAllocQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegAllocQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegAllocQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegAllocQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlLocation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlLocation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlLocation")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlLocation *)new FIX::SettlLocation();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlLocation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlLocation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlLocation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlLocation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlLocation" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlLocation" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlLocation *)new FIX::SettlLocation((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlLocation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlLocation(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlLocation__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlLocation__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlLocation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlLocation::SettlLocation()\n"
    "    FIX::SettlLocation::SettlLocation(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlLocation *arg1 = (FIX::SettlLocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlLocation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlLocation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlLocation" "', argument " "1"" of type '" "FIX::SettlLocation *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlLocation * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlLocation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlLocation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingExerciseStyle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingExerciseStyle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingExerciseStyle")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingExerciseStyle *)new FIX::UnderlyingExerciseStyle();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingExerciseStyle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingExerciseStyle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingExerciseStyle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingExerciseStyle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingExerciseStyle" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingExerciseStyle *)new FIX::UnderlyingExerciseStyle((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingExerciseStyle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingExerciseStyle(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingExerciseStyle__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingExerciseStyle__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingExerciseStyle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingExerciseStyle::UnderlyingExerciseStyle()\n"
    "    FIX::UnderlyingExerciseStyle::UnderlyingExerciseStyle(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingExerciseStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingExerciseStyle *arg1 = (FIX::UnderlyingExerciseStyle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingExerciseStyle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingExerciseStyle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingExerciseStyle" "', argument " "1"" of type '" "FIX::UnderlyingExerciseStyle *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingExerciseStyle * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingExerciseStyle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingExerciseStyle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CashSettlAgentContactName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashSettlAgentContactName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CashSettlAgentContactName")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashSettlAgentContactName *)new FIX::CashSettlAgentContactName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashSettlAgentContactName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentContactName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CashSettlAgentContactName *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CashSettlAgentContactName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CashSettlAgentContactName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CashSettlAgentContactName" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CashSettlAgentContactName *)new FIX::CashSettlAgentContactName((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CashSettlAgentContactName, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CashSettlAgentContactName(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CashSettlAgentContactName__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CashSettlAgentContactName__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CashSettlAgentContactName'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CashSettlAgentContactName::CashSettlAgentContactName()\n"
    "    FIX::CashSettlAgentContactName::CashSettlAgentContactName(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CashSettlAgentContactName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CashSettlAgentContactName *arg1 = (FIX::CashSettlAgentContactName *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CashSettlAgentContactName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CashSettlAgentContactName, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CashSettlAgentContactName" "', argument " "1"" of type '" "FIX::CashSettlAgentContactName *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CashSettlAgentContactName * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CashSettlAgentContactName_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CashSettlAgentContactName, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegRepurchaseRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegRepurchaseRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegRepurchaseRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegRepurchaseRate *)new FIX::LegRepurchaseRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegRepurchaseRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRepurchaseRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegRepurchaseRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegRepurchaseRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegRepurchaseRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegRepurchaseRate" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegRepurchaseRate *)new FIX::LegRepurchaseRate((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegRepurchaseRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegRepurchaseRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegRepurchaseRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegRepurchaseRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegRepurchaseRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegRepurchaseRate::LegRepurchaseRate()\n"
    "    FIX::LegRepurchaseRate::LegRepurchaseRate(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegRepurchaseRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegRepurchaseRate *arg1 = (FIX::LegRepurchaseRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegRepurchaseRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegRepurchaseRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegRepurchaseRate" "', argument " "1"" of type '" "FIX::LegRepurchaseRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegRepurchaseRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegRepurchaseRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegRepurchaseRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ApplResponseID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplResponseID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplResponseID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplResponseID *)new FIX::ApplResponseID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplResponseID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResponseID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplResponseID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplResponseID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplResponseID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplResponseID *)new FIX::ApplResponseID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplResponseID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplResponseID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplResponseID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplResponseID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplResponseID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplResponseID::ApplResponseID()\n"
    "    FIX::ApplResponseID::ApplResponseID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplResponseID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplResponseID *arg1 = (FIX::ApplResponseID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplResponseID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplResponseID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplResponseID" "', argument " "1"" of type '" "FIX::ApplResponseID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplResponseID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ApplResponseID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ApplResponseID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrAttrib__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDerivativeInstrAttrib *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoDerivativeInstrAttrib")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDerivativeInstrAttrib *)new FIX::NoDerivativeInstrAttrib();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDerivativeInstrAttrib, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrAttrib__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoDerivativeInstrAttrib *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoDerivativeInstrAttrib",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoDerivativeInstrAttrib" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoDerivativeInstrAttrib" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoDerivativeInstrAttrib *)new FIX::NoDerivativeInstrAttrib((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoDerivativeInstrAttrib, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoDerivativeInstrAttrib(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoDerivativeInstrAttrib__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoDerivativeInstrAttrib__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoDerivativeInstrAttrib'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoDerivativeInstrAttrib::NoDerivativeInstrAttrib()\n"
    "    FIX::NoDerivativeInstrAttrib::NoDerivativeInstrAttrib(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoDerivativeInstrAttrib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoDerivativeInstrAttrib *arg1 = (FIX::NoDerivativeInstrAttrib *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoDerivativeInstrAttrib",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoDerivativeInstrAttrib, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoDerivativeInstrAttrib" "', argument " "1"" of type '" "FIX::NoDerivativeInstrAttrib *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoDerivativeInstrAttrib * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoDerivativeInstrAttrib_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoDerivativeInstrAttrib, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeStrikeMultiplier__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeStrikeMultiplier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeStrikeMultiplier")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeStrikeMultiplier *)new FIX::DerivativeStrikeMultiplier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeStrikeMultiplier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikeMultiplier__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeStrikeMultiplier *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeStrikeMultiplier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeStrikeMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeStrikeMultiplier" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeStrikeMultiplier *)new FIX::DerivativeStrikeMultiplier((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeStrikeMultiplier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeStrikeMultiplier(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeStrikeMultiplier__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeStrikeMultiplier__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeStrikeMultiplier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeStrikeMultiplier::DerivativeStrikeMultiplier()\n"
    "    FIX::DerivativeStrikeMultiplier::DerivativeStrikeMultiplier(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeStrikeMultiplier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeStrikeMultiplier *arg1 = (FIX::DerivativeStrikeMultiplier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeStrikeMultiplier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeStrikeMultiplier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeStrikeMultiplier" "', argument " "1"" of type '" "FIX::DerivativeStrikeMultiplier *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeStrikeMultiplier * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeStrikeMultiplier_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeStrikeMultiplier, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegStrikeCurrency__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegStrikeCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegStrikeCurrency")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegStrikeCurrency *)new FIX::LegStrikeCurrency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegStrikeCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStrikeCurrency__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CURRENCY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegStrikeCurrency *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegStrikeCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CURRENCY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegStrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegStrikeCurrency" "', argument " "1"" of type '" "FIX::CURRENCY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CURRENCY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegStrikeCurrency *)new FIX::LegStrikeCurrency((FIX::CURRENCY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegStrikeCurrency, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegStrikeCurrency(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegStrikeCurrency__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CURRENCY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegStrikeCurrency__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegStrikeCurrency'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegStrikeCurrency::LegStrikeCurrency()\n"
    "    FIX::LegStrikeCurrency::LegStrikeCurrency(FIX::CURRENCY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegStrikeCurrency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegStrikeCurrency *arg1 = (FIX::LegStrikeCurrency *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegStrikeCurrency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegStrikeCurrency, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegStrikeCurrency" "', argument " "1"" of type '" "FIX::LegStrikeCurrency *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegStrikeCurrency * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegStrikeCurrency_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegStrikeCurrency, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecurityStatusReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityStatusReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecurityStatusReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityStatusReqID *)new FIX::SecurityStatusReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityStatusReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityStatusReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecurityStatusReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecurityStatusReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecurityStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecurityStatusReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecurityStatusReqID *)new FIX::SecurityStatusReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecurityStatusReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecurityStatusReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecurityStatusReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecurityStatusReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecurityStatusReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecurityStatusReqID::SecurityStatusReqID()\n"
    "    FIX::SecurityStatusReqID::SecurityStatusReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecurityStatusReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecurityStatusReqID *arg1 = (FIX::SecurityStatusReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecurityStatusReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecurityStatusReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecurityStatusReqID" "', argument " "1"" of type '" "FIX::SecurityStatusReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecurityStatusReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecurityStatusReqID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecurityStatusReqID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecureDataLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecureDataLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecureDataLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecureDataLen *)new FIX::SecureDataLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecureDataLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecureDataLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecureDataLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecureDataLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecureDataLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecureDataLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecureDataLen *)new FIX::SecureDataLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecureDataLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecureDataLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecureDataLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecureDataLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecureDataLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecureDataLen::SecureDataLen()\n"
    "    FIX::SecureDataLen::SecureDataLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecureDataLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecureDataLen *arg1 = (FIX::SecureDataLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecureDataLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecureDataLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecureDataLen" "', argument " "1"" of type '" "FIX::SecureDataLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecureDataLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecureDataLen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecureDataLen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DiscretionScope__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionScope *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DiscretionScope")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionScope *)new FIX::DiscretionScope();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionScope, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionScope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DiscretionScope *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DiscretionScope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscretionScope" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretionScope" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionScope *)new FIX::DiscretionScope((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionScope, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionScope(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DiscretionScope__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionScope__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DiscretionScope'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DiscretionScope::DiscretionScope()\n"
    "    FIX::DiscretionScope::DiscretionScope(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DiscretionScope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionScope *arg1 = (FIX::DiscretionScope *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DiscretionScope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DiscretionScope, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscretionScope" "', argument " "1"" of type '" "FIX::DiscretionScope *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DiscretionScope * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DiscretionScope_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DiscretionScope, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OwnerType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OwnerType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OwnerType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OwnerType *)new FIX::OwnerType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OwnerType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OwnerType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OwnerType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OwnerType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OwnerType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OwnerType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OwnerType *)new FIX::OwnerType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OwnerType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OwnerType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OwnerType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OwnerType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OwnerType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OwnerType::OwnerType()\n"
    "    FIX::OwnerType::OwnerType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OwnerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OwnerType *arg1 = (FIX::OwnerType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OwnerType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OwnerType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OwnerType" "', argument " "1"" of type '" "FIX::OwnerType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OwnerType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OwnerType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OwnerType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Shares__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Shares *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Shares")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Shares *)new FIX::Shares();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Shares, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Shares__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Shares *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Shares",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Shares" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Shares" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Shares *)new FIX::Shares((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Shares, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Shares(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Shares__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Shares__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Shares'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Shares::Shares()\n"
    "    FIX::Shares::Shares(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Shares(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Shares *arg1 = (FIX::Shares *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Shares",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Shares, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Shares" "', argument " "1"" of type '" "FIX::Shares *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Shares * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Shares_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Shares, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Yield__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Yield *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Yield")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Yield *)new FIX::Yield();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Yield, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Yield__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Yield *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Yield",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Yield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Yield" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Yield *)new FIX::Yield((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Yield, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Yield(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Yield__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Yield__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Yield'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Yield::Yield()\n"
    "    FIX::Yield::Yield(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Yield *arg1 = (FIX::Yield *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Yield",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Yield, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Yield" "', argument " "1"" of type '" "FIX::Yield *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Yield * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Yield_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Yield, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_QuoteRespID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteRespID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteRespID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteRespID *)new FIX::QuoteRespID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteRespID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRespID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteRespID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteRespID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteRespID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteRespID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteRespID *)new FIX::QuoteRespID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteRespID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteRespID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteRespID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteRespID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteRespID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteRespID::QuoteRespID()\n"
    "    FIX::QuoteRespID::QuoteRespID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteRespID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteRespID *arg1 = (FIX::QuoteRespID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteRespID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteRespID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteRespID" "', argument " "1"" of type '" "FIX::QuoteRespID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteRespID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteRespID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__QuoteRespID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Nested3PartySubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested3PartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested3PartySubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested3PartySubID *)new FIX::Nested3PartySubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested3PartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested3PartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested3PartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested3PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested3PartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested3PartySubID *)new FIX::Nested3PartySubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested3PartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested3PartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested3PartySubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested3PartySubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested3PartySubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested3PartySubID::Nested3PartySubID()\n"
    "    FIX::Nested3PartySubID::Nested3PartySubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested3PartySubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested3PartySubID *arg1 = (FIX::Nested3PartySubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested3PartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested3PartySubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested3PartySubID" "', argument " "1"" of type '" "FIX::Nested3PartySubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested3PartySubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Nested3PartySubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Nested3PartySubID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ApplQueueResolution__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplQueueResolution *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplQueueResolution")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplQueueResolution *)new FIX::ApplQueueResolution();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplQueueResolution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueResolution__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplQueueResolution *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplQueueResolution",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplQueueResolution" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplQueueResolution" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplQueueResolution *)new FIX::ApplQueueResolution((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplQueueResolution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplQueueResolution(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplQueueResolution__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplQueueResolution__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplQueueResolution'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplQueueResolution::ApplQueueResolution()\n"
    "    FIX::ApplQueueResolution::ApplQueueResolution(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplQueueResolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplQueueResolution *arg1 = (FIX::ApplQueueResolution *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplQueueResolution",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplQueueResolution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplQueueResolution" "', argument " "1"" of type '" "FIX::ApplQueueResolution *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplQueueResolution * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ApplQueueResolution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ApplQueueResolution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TrdRegTimestampOrigin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdRegTimestampOrigin *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TrdRegTimestampOrigin")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdRegTimestampOrigin *)new FIX::TrdRegTimestampOrigin();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdRegTimestampOrigin, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestampOrigin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TrdRegTimestampOrigin *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TrdRegTimestampOrigin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrdRegTimestampOrigin" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TrdRegTimestampOrigin" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TrdRegTimestampOrigin *)new FIX::TrdRegTimestampOrigin((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TrdRegTimestampOrigin, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrdRegTimestampOrigin(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TrdRegTimestampOrigin__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrdRegTimestampOrigin__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TrdRegTimestampOrigin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TrdRegTimestampOrigin::TrdRegTimestampOrigin()\n"
    "    FIX::TrdRegTimestampOrigin::TrdRegTimestampOrigin(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TrdRegTimestampOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TrdRegTimestampOrigin *arg1 = (FIX::TrdRegTimestampOrigin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TrdRegTimestampOrigin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TrdRegTimestampOrigin, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrdRegTimestampOrigin" "', argument " "1"" of type '" "FIX::TrdRegTimestampOrigin *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TrdRegTimestampOrigin * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TrdRegTimestampOrigin_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TrdRegTimestampOrigin, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Nested2PartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested2PartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested2PartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested2PartyRole *)new FIX::Nested2PartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested2PartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested2PartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested2PartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested2PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested2PartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested2PartyRole *)new FIX::Nested2PartyRole((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested2PartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested2PartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested2PartyRole__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested2PartyRole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested2PartyRole::Nested2PartyRole()\n"
    "    FIX::Nested2PartyRole::Nested2PartyRole(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested2PartyRole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested2PartyRole *arg1 = (FIX::Nested2PartyRole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested2PartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested2PartyRole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested2PartyRole" "', argument " "1"" of type '" "FIX::Nested2PartyRole *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested2PartyRole * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Nested2PartyRole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Nested2PartyRole, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Nested2PartyID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested2PartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nested2PartyID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested2PartyID *)new FIX::Nested2PartyID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested2PartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartyID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Nested2PartyID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nested2PartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Nested2PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nested2PartyID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Nested2PartyID *)new FIX::Nested2PartyID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Nested2PartyID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nested2PartyID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Nested2PartyID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Nested2PartyID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nested2PartyID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Nested2PartyID::Nested2PartyID()\n"
    "    FIX::Nested2PartyID::Nested2PartyID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Nested2PartyID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Nested2PartyID *arg1 = (FIX::Nested2PartyID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nested2PartyID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Nested2PartyID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nested2PartyID" "', argument " "1"" of type '" "FIX::Nested2PartyID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Nested2PartyID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Nested2PartyID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Nested2PartyID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BidSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BidSize")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidSize *)new FIX::BidSize();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BidSize *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BidSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BidSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BidSize" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidSize *)new FIX::BidSize((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidSize, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidSize(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BidSize__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidSize__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BidSize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BidSize::BidSize()\n"
    "    FIX::BidSize::BidSize(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BidSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidSize *arg1 = (FIX::BidSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BidSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BidSize, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BidSize" "', argument " "1"" of type '" "FIX::BidSize *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BidSize * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BidSize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BidSize, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegSymbolSfx__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSymbolSfx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegSymbolSfx")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSymbolSfx *)new FIX::LegSymbolSfx();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSymbolSfx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSymbolSfx__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegSymbolSfx *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegSymbolSfx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegSymbolSfx" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegSymbolSfx *)new FIX::LegSymbolSfx((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegSymbolSfx, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegSymbolSfx(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegSymbolSfx__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegSymbolSfx__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegSymbolSfx'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegSymbolSfx::LegSymbolSfx()\n"
    "    FIX::LegSymbolSfx::LegSymbolSfx(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegSymbolSfx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegSymbolSfx *arg1 = (FIX::LegSymbolSfx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegSymbolSfx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegSymbolSfx, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegSymbolSfx" "', argument " "1"" of type '" "FIX::LegSymbolSfx *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegSymbolSfx * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegSymbolSfx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegSymbolSfx, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_QuoteResponseLevel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteResponseLevel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteResponseLevel")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteResponseLevel *)new FIX::QuoteResponseLevel();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteResponseLevel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteResponseLevel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteResponseLevel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteResponseLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteResponseLevel" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteResponseLevel" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteResponseLevel *)new FIX::QuoteResponseLevel((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteResponseLevel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteResponseLevel(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteResponseLevel__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteResponseLevel__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteResponseLevel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteResponseLevel::QuoteResponseLevel()\n"
    "    FIX::QuoteResponseLevel::QuoteResponseLevel(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteResponseLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteResponseLevel *arg1 = (FIX::QuoteResponseLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteResponseLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteResponseLevel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteResponseLevel" "', argument " "1"" of type '" "FIX::QuoteResponseLevel *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteResponseLevel * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteResponseLevel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__QuoteResponseLevel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BodyLength__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BodyLength *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BodyLength")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BodyLength *)new FIX::BodyLength();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BodyLength, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BodyLength__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BodyLength *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BodyLength",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BodyLength" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BodyLength" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BodyLength *)new FIX::BodyLength((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BodyLength, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BodyLength(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BodyLength__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BodyLength__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BodyLength'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BodyLength::BodyLength()\n"
    "    FIX::BodyLength::BodyLength(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BodyLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BodyLength *arg1 = (FIX::BodyLength *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BodyLength",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BodyLength, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BodyLength" "', argument " "1"" of type '" "FIX::BodyLength *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BodyLength * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BodyLength_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BodyLength, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ListExecInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListExecInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ListExecInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListExecInst *)new FIX::ListExecInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListExecInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListExecInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ListExecInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ListExecInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ListExecInst" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ListExecInst" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ListExecInst *)new FIX::ListExecInst((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ListExecInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ListExecInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ListExecInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ListExecInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ListExecInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ListExecInst::ListExecInst()\n"
    "    FIX::ListExecInst::ListExecInst(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ListExecInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ListExecInst *arg1 = (FIX::ListExecInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ListExecInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ListExecInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ListExecInst" "', argument " "1"" of type '" "FIX::ListExecInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ListExecInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ListExecInst_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ListExecInst, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExecAckStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecAckStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExecAckStatus")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecAckStatus *)new FIX::ExecAckStatus();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecAckStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecAckStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExecAckStatus *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExecAckStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExecAckStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExecAckStatus" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecAckStatus *)new FIX::ExecAckStatus((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecAckStatus, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecAckStatus(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExecAckStatus__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecAckStatus__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExecAckStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExecAckStatus::ExecAckStatus()\n"
    "    FIX::ExecAckStatus::ExecAckStatus(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExecAckStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecAckStatus *arg1 = (FIX::ExecAckStatus *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExecAckStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExecAckStatus, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExecAckStatus" "', argument " "1"" of type '" "FIX::ExecAckStatus *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExecAckStatus * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExecAckStatus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ExecAckStatus, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlDate2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlDate2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlDate2")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlDate2 *)new FIX::SettlDate2();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlDate2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDate2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlDate2 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlDate2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlDate2" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlDate2" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlDate2 *)new FIX::SettlDate2((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlDate2, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlDate2(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlDate2__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlDate2__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlDate2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlDate2::SettlDate2()\n"
    "    FIX::SettlDate2::SettlDate2(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlDate2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlDate2 *arg1 = (FIX::SettlDate2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlDate2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlDate2, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlDate2" "', argument " "1"" of type '" "FIX::SettlDate2 *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlDate2 * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlDate2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlDate2, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NetGrossInd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NetGrossInd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NetGrossInd")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NetGrossInd *)new FIX::NetGrossInd();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NetGrossInd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetGrossInd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NetGrossInd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NetGrossInd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NetGrossInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NetGrossInd" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NetGrossInd *)new FIX::NetGrossInd((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NetGrossInd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetGrossInd(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NetGrossInd__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NetGrossInd__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NetGrossInd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NetGrossInd::NetGrossInd()\n"
    "    FIX::NetGrossInd::NetGrossInd(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NetGrossInd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NetGrossInd *arg1 = (FIX::NetGrossInd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NetGrossInd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NetGrossInd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NetGrossInd" "', argument " "1"" of type '" "FIX::NetGrossInd *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NetGrossInd * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NetGrossInd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NetGrossInd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityAltIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecurityAltIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingSecurityAltIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecurityAltIDSource *)new FIX::UnderlyingSecurityAltIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecurityAltIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityAltIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingSecurityAltIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingSecurityAltIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingSecurityAltIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingSecurityAltIDSource *)new FIX::UnderlyingSecurityAltIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingSecurityAltIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingSecurityAltIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingSecurityAltIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingSecurityAltIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingSecurityAltIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingSecurityAltIDSource::UnderlyingSecurityAltIDSource()\n"
    "    FIX::UnderlyingSecurityAltIDSource::UnderlyingSecurityAltIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingSecurityAltIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingSecurityAltIDSource *arg1 = (FIX::UnderlyingSecurityAltIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingSecurityAltIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingSecurityAltIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingSecurityAltIDSource" "', argument " "1"" of type '" "FIX::UnderlyingSecurityAltIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingSecurityAltIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingSecurityAltIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingSecurityAltIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TestReqID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TestReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TestReqID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TestReqID *)new FIX::TestReqID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TestReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TestReqID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TestReqID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TestReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TestReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TestReqID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TestReqID *)new FIX::TestReqID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TestReqID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TestReqID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TestReqID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TestReqID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TestReqID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TestReqID::TestReqID()\n"
    "    FIX::TestReqID::TestReqID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TestReqID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TestReqID *arg1 = (FIX::TestReqID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TestReqID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TestReqID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TestReqID" "', argument " "1"" of type '" "FIX::TestReqID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TestReqID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TestReqID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TestReqID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CxlType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CxlType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CxlType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CxlType *)new FIX::CxlType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CxlType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CxlType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CxlType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CxlType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CxlType" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CxlType *)new FIX::CxlType((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CxlType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CxlType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CxlType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CxlType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CxlType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CxlType::CxlType()\n"
    "    FIX::CxlType::CxlType(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CxlType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CxlType *arg1 = (FIX::CxlType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CxlType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CxlType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CxlType" "', argument " "1"" of type '" "FIX::CxlType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CxlType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CxlType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CxlType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingCreditRating__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCreditRating *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingCreditRating")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCreditRating *)new FIX::UnderlyingCreditRating();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCreditRating, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCreditRating__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingCreditRating *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingCreditRating",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingCreditRating" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingCreditRating" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCreditRating *)new FIX::UnderlyingCreditRating((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCreditRating, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCreditRating(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingCreditRating__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCreditRating__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingCreditRating'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingCreditRating::UnderlyingCreditRating()\n"
    "    FIX::UnderlyingCreditRating::UnderlyingCreditRating(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingCreditRating(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCreditRating *arg1 = (FIX::UnderlyingCreditRating *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingCreditRating",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingCreditRating, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingCreditRating" "', argument " "1"" of type '" "FIX::UnderlyingCreditRating *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingCreditRating * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingCreditRating_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingCreditRating, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AvgPxPrecision__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AvgPxPrecision *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AvgPxPrecision")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AvgPxPrecision *)new FIX::AvgPxPrecision();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AvgPxPrecision, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPxPrecision__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AvgPxPrecision *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AvgPxPrecision",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AvgPxPrecision" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AvgPxPrecision" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AvgPxPrecision *)new FIX::AvgPxPrecision((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AvgPxPrecision, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AvgPxPrecision(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AvgPxPrecision__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AvgPxPrecision__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AvgPxPrecision'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AvgPxPrecision::AvgPxPrecision()\n"
    "    FIX::AvgPxPrecision::AvgPxPrecision(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AvgPxPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AvgPxPrecision *arg1 = (FIX::AvgPxPrecision *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AvgPxPrecision",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AvgPxPrecision, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AvgPxPrecision" "', argument " "1"" of type '" "FIX::AvgPxPrecision *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AvgPxPrecision * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AvgPxPrecision_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AvgPxPrecision, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BenchmarkPriceType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BenchmarkPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BenchmarkPriceType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BenchmarkPriceType *)new FIX::BenchmarkPriceType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BenchmarkPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkPriceType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BenchmarkPriceType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BenchmarkPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BenchmarkPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BenchmarkPriceType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BenchmarkPriceType *)new FIX::BenchmarkPriceType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BenchmarkPriceType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BenchmarkPriceType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BenchmarkPriceType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BenchmarkPriceType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BenchmarkPriceType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BenchmarkPriceType::BenchmarkPriceType()\n"
    "    FIX::BenchmarkPriceType::BenchmarkPriceType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BenchmarkPriceType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BenchmarkPriceType *arg1 = (FIX::BenchmarkPriceType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BenchmarkPriceType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BenchmarkPriceType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BenchmarkPriceType" "', argument " "1"" of type '" "FIX::BenchmarkPriceType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BenchmarkPriceType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BenchmarkPriceType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BenchmarkPriceType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DeskTypeSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeskTypeSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DeskTypeSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeskTypeSource *)new FIX::DeskTypeSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeskTypeSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskTypeSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DeskTypeSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DeskTypeSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeskTypeSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeskTypeSource" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DeskTypeSource *)new FIX::DeskTypeSource((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DeskTypeSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DeskTypeSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DeskTypeSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeskTypeSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DeskTypeSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DeskTypeSource::DeskTypeSource()\n"
    "    FIX::DeskTypeSource::DeskTypeSource(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DeskTypeSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DeskTypeSource *arg1 = (FIX::DeskTypeSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DeskTypeSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DeskTypeSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeskTypeSource" "', argument " "1"" of type '" "FIX::DeskTypeSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DeskTypeSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DeskTypeSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DeskTypeSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DiscretionRoundDirection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionRoundDirection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DiscretionRoundDirection")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionRoundDirection *)new FIX::DiscretionRoundDirection();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionRoundDirection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionRoundDirection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DiscretionRoundDirection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DiscretionRoundDirection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscretionRoundDirection" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretionRoundDirection" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionRoundDirection *)new FIX::DiscretionRoundDirection((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionRoundDirection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionRoundDirection(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DiscretionRoundDirection__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionRoundDirection__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DiscretionRoundDirection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DiscretionRoundDirection::DiscretionRoundDirection()\n"
    "    FIX::DiscretionRoundDirection::DiscretionRoundDirection(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DiscretionRoundDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionRoundDirection *arg1 = (FIX::DiscretionRoundDirection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DiscretionRoundDirection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DiscretionRoundDirection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscretionRoundDirection" "', argument " "1"" of type '" "FIX::DiscretionRoundDirection *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DiscretionRoundDirection * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DiscretionRoundDirection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DiscretionRoundDirection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OrigSecondaryTradeID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigSecondaryTradeID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrigSecondaryTradeID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigSecondaryTradeID *)new FIX::OrigSecondaryTradeID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigSecondaryTradeID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigSecondaryTradeID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrigSecondaryTradeID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrigSecondaryTradeID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrigSecondaryTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrigSecondaryTradeID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrigSecondaryTradeID *)new FIX::OrigSecondaryTradeID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrigSecondaryTradeID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrigSecondaryTradeID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrigSecondaryTradeID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrigSecondaryTradeID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrigSecondaryTradeID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrigSecondaryTradeID::OrigSecondaryTradeID()\n"
    "    FIX::OrigSecondaryTradeID::OrigSecondaryTradeID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrigSecondaryTradeID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrigSecondaryTradeID *arg1 = (FIX::OrigSecondaryTradeID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrigSecondaryTradeID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrigSecondaryTradeID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrigSecondaryTradeID" "', argument " "1"" of type '" "FIX::OrigSecondaryTradeID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrigSecondaryTradeID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrigSecondaryTradeID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrigSecondaryTradeID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ReceivedDeptID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ReceivedDeptID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ReceivedDeptID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ReceivedDeptID *)new FIX::ReceivedDeptID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ReceivedDeptID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReceivedDeptID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ReceivedDeptID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ReceivedDeptID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ReceivedDeptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ReceivedDeptID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ReceivedDeptID *)new FIX::ReceivedDeptID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ReceivedDeptID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ReceivedDeptID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ReceivedDeptID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ReceivedDeptID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ReceivedDeptID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ReceivedDeptID::ReceivedDeptID()\n"
    "    FIX::ReceivedDeptID::ReceivedDeptID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ReceivedDeptID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ReceivedDeptID *arg1 = (FIX::ReceivedDeptID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ReceivedDeptID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ReceivedDeptID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ReceivedDeptID" "', argument " "1"" of type '" "FIX::ReceivedDeptID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ReceivedDeptID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ReceivedDeptID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ReceivedDeptID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MaturityNetMoney__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityNetMoney *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MaturityNetMoney")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityNetMoney *)new FIX::MaturityNetMoney();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityNetMoney, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityNetMoney__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AMT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MaturityNetMoney *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MaturityNetMoney",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__AMT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MaturityNetMoney" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MaturityNetMoney" "', argument " "1"" of type '" "FIX::AMT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::AMT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MaturityNetMoney *)new FIX::MaturityNetMoney((FIX::AMT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MaturityNetMoney, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MaturityNetMoney(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MaturityNetMoney__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__AMT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaturityNetMoney__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MaturityNetMoney'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MaturityNetMoney::MaturityNetMoney()\n"
    "    FIX::MaturityNetMoney::MaturityNetMoney(FIX::AMT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MaturityNetMoney(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MaturityNetMoney *arg1 = (FIX::MaturityNetMoney *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MaturityNetMoney",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MaturityNetMoney, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MaturityNetMoney" "', argument " "1"" of type '" "FIX::MaturityNetMoney *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MaturityNetMoney * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MaturityNetMoney_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MaturityNetMoney, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BidDescriptorType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidDescriptorType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BidDescriptorType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidDescriptorType *)new FIX::BidDescriptorType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidDescriptorType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidDescriptorType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BidDescriptorType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BidDescriptorType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BidDescriptorType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BidDescriptorType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BidDescriptorType *)new FIX::BidDescriptorType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BidDescriptorType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BidDescriptorType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BidDescriptorType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BidDescriptorType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BidDescriptorType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BidDescriptorType::BidDescriptorType()\n"
    "    FIX::BidDescriptorType::BidDescriptorType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BidDescriptorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BidDescriptorType *arg1 = (FIX::BidDescriptorType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BidDescriptorType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BidDescriptorType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BidDescriptorType" "', argument " "1"" of type '" "FIX::BidDescriptorType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BidDescriptorType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BidDescriptorType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BidDescriptorType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartySubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrumentPartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativeInstrumentPartySubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrumentPartySubID *)new FIX::DerivativeInstrumentPartySubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrumentPartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativeInstrumentPartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativeInstrumentPartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeInstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeInstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativeInstrumentPartySubID *)new FIX::DerivativeInstrumentPartySubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativeInstrumentPartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativeInstrumentPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativeInstrumentPartySubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativeInstrumentPartySubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativeInstrumentPartySubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativeInstrumentPartySubID::DerivativeInstrumentPartySubID()\n"
    "    FIX::DerivativeInstrumentPartySubID::DerivativeInstrumentPartySubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativeInstrumentPartySubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativeInstrumentPartySubID *arg1 = (FIX::DerivativeInstrumentPartySubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativeInstrumentPartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativeInstrumentPartySubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeInstrumentPartySubID" "', argument " "1"" of type '" "FIX::DerivativeInstrumentPartySubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativeInstrumentPartySubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativeInstrumentPartySubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativeInstrumentPartySubID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NetworkStatusResponseType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NetworkStatusResponseType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NetworkStatusResponseType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NetworkStatusResponseType *)new FIX::NetworkStatusResponseType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NetworkStatusResponseType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkStatusResponseType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NetworkStatusResponseType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NetworkStatusResponseType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NetworkStatusResponseType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NetworkStatusResponseType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NetworkStatusResponseType *)new FIX::NetworkStatusResponseType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NetworkStatusResponseType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NetworkStatusResponseType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NetworkStatusResponseType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NetworkStatusResponseType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NetworkStatusResponseType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NetworkStatusResponseType::NetworkStatusResponseType()\n"
    "    FIX::NetworkStatusResponseType::NetworkStatusResponseType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NetworkStatusResponseType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NetworkStatusResponseType *arg1 = (FIX::NetworkStatusResponseType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NetworkStatusResponseType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NetworkStatusResponseType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NetworkStatusResponseType" "', argument " "1"" of type '" "FIX::NetworkStatusResponseType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NetworkStatusResponseType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NetworkStatusResponseType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NetworkStatusResponseType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DateOfBirth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateOfBirth *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DateOfBirth")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DateOfBirth *)new FIX::DateOfBirth();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DateOfBirth, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateOfBirth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DateOfBirth *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DateOfBirth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateOfBirth" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateOfBirth" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DateOfBirth *)new FIX::DateOfBirth((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DateOfBirth, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DateOfBirth(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DateOfBirth__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DateOfBirth__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DateOfBirth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DateOfBirth::DateOfBirth()\n"
    "    FIX::DateOfBirth::DateOfBirth(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DateOfBirth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DateOfBirth *arg1 = (FIX::DateOfBirth *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DateOfBirth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DateOfBirth, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateOfBirth" "', argument " "1"" of type '" "FIX::DateOfBirth *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DateOfBirth * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DateOfBirth_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DateOfBirth, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StartStrikePxRange__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StartStrikePxRange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StartStrikePxRange")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StartStrikePxRange *)new FIX::StartStrikePxRange();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StartStrikePxRange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartStrikePxRange__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PRICE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StartStrikePxRange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StartStrikePxRange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PRICE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StartStrikePxRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StartStrikePxRange" "', argument " "1"" of type '" "FIX::PRICE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PRICE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StartStrikePxRange *)new FIX::StartStrikePxRange((FIX::PRICE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StartStrikePxRange, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StartStrikePxRange(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StartStrikePxRange__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PRICE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StartStrikePxRange__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StartStrikePxRange'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StartStrikePxRange::StartStrikePxRange()\n"
    "    FIX::StartStrikePxRange::StartStrikePxRange(FIX::PRICE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StartStrikePxRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StartStrikePxRange *arg1 = (FIX::StartStrikePxRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StartStrikePxRange",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StartStrikePxRange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StartStrikePxRange" "', argument " "1"" of type '" "FIX::StartStrikePxRange *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StartStrikePxRange * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StartStrikePxRange_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__StartStrikePxRange, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartySubID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UndlyInstrumentPartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UndlyInstrumentPartySubID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UndlyInstrumentPartySubID *)new FIX::UndlyInstrumentPartySubID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UndlyInstrumentPartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartySubID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UndlyInstrumentPartySubID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UndlyInstrumentPartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UndlyInstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UndlyInstrumentPartySubID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UndlyInstrumentPartySubID *)new FIX::UndlyInstrumentPartySubID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UndlyInstrumentPartySubID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UndlyInstrumentPartySubID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UndlyInstrumentPartySubID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UndlyInstrumentPartySubID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UndlyInstrumentPartySubID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UndlyInstrumentPartySubID::UndlyInstrumentPartySubID()\n"
    "    FIX::UndlyInstrumentPartySubID::UndlyInstrumentPartySubID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UndlyInstrumentPartySubID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UndlyInstrumentPartySubID *arg1 = (FIX::UndlyInstrumentPartySubID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UndlyInstrumentPartySubID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UndlyInstrumentPartySubID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UndlyInstrumentPartySubID" "', argument " "1"" of type '" "FIX::UndlyInstrumentPartySubID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UndlyInstrumentPartySubID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UndlyInstrumentPartySubID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UndlyInstrumentPartySubID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SecondaryTradeReportRefID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryTradeReportRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SecondaryTradeReportRefID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryTradeReportRefID *)new FIX::SecondaryTradeReportRefID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryTradeReportRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradeReportRefID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SecondaryTradeReportRefID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SecondaryTradeReportRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SecondaryTradeReportRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SecondaryTradeReportRefID" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SecondaryTradeReportRefID *)new FIX::SecondaryTradeReportRefID((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SecondaryTradeReportRefID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SecondaryTradeReportRefID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SecondaryTradeReportRefID__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SecondaryTradeReportRefID__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SecondaryTradeReportRefID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SecondaryTradeReportRefID::SecondaryTradeReportRefID()\n"
    "    FIX::SecondaryTradeReportRefID::SecondaryTradeReportRefID(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SecondaryTradeReportRefID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SecondaryTradeReportRefID *arg1 = (FIX::SecondaryTradeReportRefID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SecondaryTradeReportRefID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SecondaryTradeReportRefID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondaryTradeReportRefID" "', argument " "1"" of type '" "FIX::SecondaryTradeReportRefID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SecondaryTradeReportRefID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SecondaryTradeReportRefID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SecondaryTradeReportRefID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingCPRegType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCPRegType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingCPRegType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCPRegType *)new FIX::UnderlyingCPRegType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCPRegType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCPRegType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingCPRegType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingCPRegType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingCPRegType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingCPRegType" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingCPRegType *)new FIX::UnderlyingCPRegType((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingCPRegType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingCPRegType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingCPRegType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingCPRegType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingCPRegType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingCPRegType::UnderlyingCPRegType()\n"
    "    FIX::UnderlyingCPRegType::UnderlyingCPRegType(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingCPRegType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingCPRegType *arg1 = (FIX::UnderlyingCPRegType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingCPRegType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingCPRegType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingCPRegType" "', argument " "1"" of type '" "FIX::UnderlyingCPRegType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingCPRegType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingCPRegType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingCPRegType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SignatureLength__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SignatureLength *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SignatureLength")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SignatureLength *)new FIX::SignatureLength();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SignatureLength, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SignatureLength__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SignatureLength *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SignatureLength",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SignatureLength" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SignatureLength" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SignatureLength *)new FIX::SignatureLength((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SignatureLength, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SignatureLength(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SignatureLength__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SignatureLength__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SignatureLength'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SignatureLength::SignatureLength()\n"
    "    FIX::SignatureLength::SignatureLength(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SignatureLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SignatureLength *arg1 = (FIX::SignatureLength *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SignatureLength",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SignatureLength, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SignatureLength" "', argument " "1"" of type '" "FIX::SignatureLength *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SignatureLength * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SignatureLength_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SignatureLength, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OrderQty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OrderQty")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderQty *)new FIX::OrderQty();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderQty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QTY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OrderQty *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OrderQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__QTY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrderQty" "', argument " "1"" of type '" "FIX::QTY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::QTY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OrderQty *)new FIX::OrderQty((FIX::QTY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OrderQty, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OrderQty(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OrderQty__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__QTY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OrderQty__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrderQty'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OrderQty::OrderQty()\n"
    "    FIX::OrderQty::OrderQty(FIX::QTY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OrderQty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OrderQty *arg1 = (FIX::OrderQty *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OrderQty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OrderQty, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrderQty" "', argument " "1"" of type '" "FIX::OrderQty *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OrderQty * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OrderQty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OrderQty, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OriginalNotionalPercentageOutstanding__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OriginalNotionalPercentageOutstanding *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_OriginalNotionalPercentageOutstanding")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OriginalNotionalPercentageOutstanding *)new FIX::OriginalNotionalPercentageOutstanding();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OriginalNotionalPercentageOutstanding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OriginalNotionalPercentageOutstanding__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::PERCENTAGE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::OriginalNotionalPercentageOutstanding *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_OriginalNotionalPercentageOutstanding",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__PERCENTAGE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OriginalNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OriginalNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::PERCENTAGE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::PERCENTAGE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::OriginalNotionalPercentageOutstanding *)new FIX::OriginalNotionalPercentageOutstanding((FIX::PERCENTAGE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__OriginalNotionalPercentageOutstanding, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_OriginalNotionalPercentageOutstanding(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_OriginalNotionalPercentageOutstanding__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__PERCENTAGE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_OriginalNotionalPercentageOutstanding__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OriginalNotionalPercentageOutstanding'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::OriginalNotionalPercentageOutstanding::OriginalNotionalPercentageOutstanding()\n"
    "    FIX::OriginalNotionalPercentageOutstanding::OriginalNotionalPercentageOutstanding(FIX::PERCENTAGE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_OriginalNotionalPercentageOutstanding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::OriginalNotionalPercentageOutstanding *arg1 = (FIX::OriginalNotionalPercentageOutstanding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OriginalNotionalPercentageOutstanding",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__OriginalNotionalPercentageOutstanding, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OriginalNotionalPercentageOutstanding" "', argument " "1"" of type '" "FIX::OriginalNotionalPercentageOutstanding *""'"); 
  }
  arg1 = reinterpret_cast< FIX::OriginalNotionalPercentageOutstanding * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OriginalNotionalPercentageOutstanding_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__OriginalNotionalPercentageOutstanding, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingTimeUnit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingTimeUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingTimeUnit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingTimeUnit *)new FIX::UnderlyingTimeUnit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingTimeUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingTimeUnit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingTimeUnit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingTimeUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingTimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingTimeUnit" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingTimeUnit *)new FIX::UnderlyingTimeUnit((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingTimeUnit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingTimeUnit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingTimeUnit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingTimeUnit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingTimeUnit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingTimeUnit::UnderlyingTimeUnit()\n"
    "    FIX::UnderlyingTimeUnit::UnderlyingTimeUnit(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingTimeUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingTimeUnit *arg1 = (FIX::UnderlyingTimeUnit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingTimeUnit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingTimeUnit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingTimeUnit" "', argument " "1"" of type '" "FIX::UnderlyingTimeUnit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingTimeUnit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingTimeUnit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingTimeUnit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncodedHeadlineLen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedHeadlineLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedHeadlineLen")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedHeadlineLen *)new FIX::EncodedHeadlineLen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedHeadlineLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedHeadlineLen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LENGTH *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedHeadlineLen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedHeadlineLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LENGTH,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedHeadlineLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedHeadlineLen" "', argument " "1"" of type '" "FIX::LENGTH const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LENGTH * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedHeadlineLen *)new FIX::EncodedHeadlineLen((FIX::LENGTH const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedHeadlineLen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedHeadlineLen(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedHeadlineLen__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LENGTH, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedHeadlineLen__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedHeadlineLen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedHeadlineLen::EncodedHeadlineLen()\n"
    "    FIX::EncodedHeadlineLen::EncodedHeadlineLen(FIX::LENGTH const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedHeadlineLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedHeadlineLen *arg1 = (FIX::EncodedHeadlineLen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedHeadlineLen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedHeadlineLen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedHeadlineLen" "', argument " "1"" of type '" "FIX::EncodedHeadlineLen *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedHeadlineLen * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncodedHeadlineLen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedHeadlineLen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoRegistDtls__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRegistDtls *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoRegistDtls")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRegistDtls *)new FIX::NoRegistDtls();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRegistDtls, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRegistDtls__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoRegistDtls *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoRegistDtls",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoRegistDtls" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoRegistDtls" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoRegistDtls *)new FIX::NoRegistDtls((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoRegistDtls, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoRegistDtls(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoRegistDtls__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoRegistDtls__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoRegistDtls'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoRegistDtls::NoRegistDtls()\n"
    "    FIX::NoRegistDtls::NoRegistDtls(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoRegistDtls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoRegistDtls *arg1 = (FIX::NoRegistDtls *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoRegistDtls",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoRegistDtls, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoRegistDtls" "', argument " "1"" of type '" "FIX::NoRegistDtls *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoRegistDtls * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoRegistDtls_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoRegistDtls, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StrategyParameterValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrategyParameterValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StrategyParameterValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrategyParameterValue *)new FIX::StrategyParameterValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrategyParameterValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrategyParameterValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StrategyParameterValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StrategyParameterValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StrategyParameterValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StrategyParameterValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StrategyParameterValue *)new FIX::StrategyParameterValue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StrategyParameterValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StrategyParameterValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StrategyParameterValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StrategyParameterValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StrategyParameterValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StrategyParameterValue::StrategyParameterValue()\n"
    "    FIX::StrategyParameterValue::StrategyParameterValue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StrategyParameterValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StrategyParameterValue *arg1 = (FIX::StrategyParameterValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StrategyParameterValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StrategyParameterValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StrategyParameterValue" "', argument " "1"" of type '" "FIX::StrategyParameterValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StrategyParameterValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StrategyParameterValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__StrategyParameterValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoInstrumentParties__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoInstrumentParties *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoInstrumentParties")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoInstrumentParties *)new FIX::NoInstrumentParties();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoInstrumentParties, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoInstrumentParties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoInstrumentParties *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoInstrumentParties",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoInstrumentParties" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoInstrumentParties" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoInstrumentParties *)new FIX::NoInstrumentParties((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoInstrumentParties, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoInstrumentParties(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoInstrumentParties__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoInstrumentParties__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoInstrumentParties'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoInstrumentParties::NoInstrumentParties()\n"
    "    FIX::NoInstrumentParties::NoInstrumentParties(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoInstrumentParties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoInstrumentParties *arg1 = (FIX::NoInstrumentParties *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoInstrumentParties",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoInstrumentParties, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoInstrumentParties" "', argument " "1"" of type '" "FIX::NoInstrumentParties *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoInstrumentParties * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoInstrumentParties_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoInstrumentParties, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_QuoteType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_QuoteType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteType *)new FIX::QuoteType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::QuoteType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_QuoteType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuoteType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuoteType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::QuoteType *)new FIX::QuoteType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__QuoteType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_QuoteType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_QuoteType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_QuoteType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_QuoteType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::QuoteType::QuoteType()\n"
    "    FIX::QuoteType::QuoteType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_QuoteType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::QuoteType *arg1 = (FIX::QuoteType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_QuoteType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__QuoteType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuoteType" "', argument " "1"" of type '" "FIX::QuoteType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::QuoteType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *QuoteType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__QuoteType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NoStrategyParameters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoStrategyParameters *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NoStrategyParameters")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoStrategyParameters *)new FIX::NoStrategyParameters();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoStrategyParameters, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStrategyParameters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NUMINGROUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::NoStrategyParameters *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NoStrategyParameters",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__NUMINGROUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NoStrategyParameters" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NoStrategyParameters" "', argument " "1"" of type '" "FIX::NUMINGROUP const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::NUMINGROUP * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NoStrategyParameters *)new FIX::NoStrategyParameters((FIX::NUMINGROUP const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NoStrategyParameters, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NoStrategyParameters(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_NoStrategyParameters__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__NUMINGROUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NoStrategyParameters__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NoStrategyParameters'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::NoStrategyParameters::NoStrategyParameters()\n"
    "    FIX::NoStrategyParameters::NoStrategyParameters(FIX::NUMINGROUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NoStrategyParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NoStrategyParameters *arg1 = (FIX::NoStrategyParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NoStrategyParameters",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NoStrategyParameters, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NoStrategyParameters" "', argument " "1"" of type '" "FIX::NoStrategyParameters *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NoStrategyParameters * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NoStrategyParameters_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NoStrategyParameters, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_IndividualAllocRejCode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IndividualAllocRejCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IndividualAllocRejCode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IndividualAllocRejCode *)new FIX::IndividualAllocRejCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IndividualAllocRejCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndividualAllocRejCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IndividualAllocRejCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IndividualAllocRejCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IndividualAllocRejCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IndividualAllocRejCode" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IndividualAllocRejCode *)new FIX::IndividualAllocRejCode((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IndividualAllocRejCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IndividualAllocRejCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IndividualAllocRejCode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IndividualAllocRejCode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IndividualAllocRejCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IndividualAllocRejCode::IndividualAllocRejCode()\n"
    "    FIX::IndividualAllocRejCode::IndividualAllocRejCode(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IndividualAllocRejCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IndividualAllocRejCode *arg1 = (FIX::IndividualAllocRejCode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IndividualAllocRejCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IndividualAllocRejCode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IndividualAllocRejCode" "', argument " "1"" of type '" "FIX::IndividualAllocRejCode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IndividualAllocRejCode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IndividualAllocRejCode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__IndividualAllocRejCode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DiscretionInst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DiscretionInst")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionInst *)new FIX::DiscretionInst();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionInst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DiscretionInst *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DiscretionInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscretionInst" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscretionInst" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DiscretionInst *)new FIX::DiscretionInst((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DiscretionInst, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DiscretionInst(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DiscretionInst__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DiscretionInst__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DiscretionInst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DiscretionInst::DiscretionInst()\n"
    "    FIX::DiscretionInst::DiscretionInst(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DiscretionInst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DiscretionInst *arg1 = (FIX::DiscretionInst *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DiscretionInst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DiscretionInst, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscretionInst" "', argument " "1"" of type '" "FIX::DiscretionInst *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DiscretionInst * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DiscretionInst_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DiscretionInst, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TargetPartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TargetPartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetPartyRole *)new FIX::TargetPartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TargetPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TargetPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TargetPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TargetPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetPartyRole *)new FIX::TargetPartyRole((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TargetPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TargetPartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TargetPartyRole__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TargetPartyRole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TargetPartyRole::TargetPartyRole()\n"
    "    FIX::TargetPartyRole::TargetPartyRole(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TargetPartyRole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TargetPartyRole *arg1 = (FIX::TargetPartyRole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TargetPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TargetPartyRole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TargetPartyRole" "', argument " "1"" of type '" "FIX::TargetPartyRole *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TargetPartyRole * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TargetPartyRole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TargetPartyRole, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CrossPrioritization__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CrossPrioritization *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CrossPrioritization")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CrossPrioritization *)new FIX::CrossPrioritization();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CrossPrioritization, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossPrioritization__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::CrossPrioritization *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CrossPrioritization",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CrossPrioritization" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CrossPrioritization" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::CrossPrioritization *)new FIX::CrossPrioritization((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__CrossPrioritization, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CrossPrioritization(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_CrossPrioritization__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CrossPrioritization__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CrossPrioritization'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::CrossPrioritization::CrossPrioritization()\n"
    "    FIX::CrossPrioritization::CrossPrioritization(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CrossPrioritization(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CrossPrioritization *arg1 = (FIX::CrossPrioritization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CrossPrioritization",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__CrossPrioritization, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CrossPrioritization" "', argument " "1"" of type '" "FIX::CrossPrioritization *""'"); 
  }
  arg1 = reinterpret_cast< FIX::CrossPrioritization * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CrossPrioritization_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__CrossPrioritization, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EncodedListStatusText__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedListStatusText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EncodedListStatusText")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedListStatusText *)new FIX::EncodedListStatusText();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedListStatusText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListStatusText__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DATA *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::EncodedListStatusText *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EncodedListStatusText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DATA,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EncodedListStatusText" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EncodedListStatusText" "', argument " "1"" of type '" "FIX::DATA const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DATA * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::EncodedListStatusText *)new FIX::EncodedListStatusText((FIX::DATA const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__EncodedListStatusText, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EncodedListStatusText(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_EncodedListStatusText__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DATA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_EncodedListStatusText__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EncodedListStatusText'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::EncodedListStatusText::EncodedListStatusText()\n"
    "    FIX::EncodedListStatusText::EncodedListStatusText(FIX::DATA const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_EncodedListStatusText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::EncodedListStatusText *arg1 = (FIX::EncodedListStatusText *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EncodedListStatusText",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__EncodedListStatusText, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncodedListStatusText" "', argument " "1"" of type '" "FIX::EncodedListStatusText *""'"); 
  }
  arg1 = reinterpret_cast< FIX::EncodedListStatusText * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EncodedListStatusText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__EncodedListStatusText, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_IOIOthSvc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIOthSvc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_IOIOthSvc")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIOthSvc *)new FIX::IOIOthSvc();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIOthSvc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIOthSvc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::IOIOthSvc *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_IOIOthSvc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IOIOthSvc" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IOIOthSvc" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::IOIOthSvc *)new FIX::IOIOthSvc((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__IOIOthSvc, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IOIOthSvc(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_IOIOthSvc__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IOIOthSvc__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IOIOthSvc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::IOIOthSvc::IOIOthSvc()\n"
    "    FIX::IOIOthSvc::IOIOthSvc(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_IOIOthSvc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::IOIOthSvc *arg1 = (FIX::IOIOthSvc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_IOIOthSvc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__IOIOthSvc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IOIOthSvc" "', argument " "1"" of type '" "FIX::IOIOthSvc *""'"); 
  }
  arg1 = reinterpret_cast< FIX::IOIOthSvc * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IOIOthSvc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__IOIOthSvc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LegIssueDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegIssueDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LegIssueDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegIssueDate *)new FIX::LegIssueDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegIssueDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIssueDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::LegIssueDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LegIssueDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LegIssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LegIssueDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::LegIssueDate *)new FIX::LegIssueDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__LegIssueDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LegIssueDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_LegIssueDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LegIssueDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LegIssueDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LegIssueDate::LegIssueDate()\n"
    "    FIX::LegIssueDate::LegIssueDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LegIssueDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LegIssueDate *arg1 = (FIX::LegIssueDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LegIssueDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LegIssueDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegIssueDate" "', argument " "1"" of type '" "FIX::LegIssueDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LegIssueDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LegIssueDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LegIssueDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MDReqRejReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDReqRejReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MDReqRejReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDReqRejReason *)new FIX::MDReqRejReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDReqRejReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDReqRejReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::CHAR *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MDReqRejReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MDReqRejReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__CHAR,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MDReqRejReason" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MDReqRejReason" "', argument " "1"" of type '" "FIX::CHAR const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::CHAR * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MDReqRejReason *)new FIX::MDReqRejReason((FIX::CHAR const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MDReqRejReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MDReqRejReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_MDReqRejReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__CHAR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MDReqRejReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MDReqRejReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::MDReqRejReason::MDReqRejReason()\n"
    "    FIX::MDReqRejReason::MDReqRejReason(FIX::CHAR const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MDReqRejReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MDReqRejReason *arg1 = (FIX::MDReqRejReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MDReqRejReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MDReqRejReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MDReqRejReason" "', argument " "1"" of type '" "FIX::MDReqRejReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MDReqRejReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MDReqRejReason_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MDReqRejReason, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ApplReqType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplReqType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ApplReqType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplReqType *)new FIX::ApplReqType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplReqType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReqType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ApplReqType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ApplReqType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ApplReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ApplReqType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ApplReqType *)new FIX::ApplReqType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ApplReqType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ApplReqType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ApplReqType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ApplReqType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ApplReqType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ApplReqType::ApplReqType()\n"
    "    FIX::ApplReqType::ApplReqType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ApplReqType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ApplReqType *arg1 = (FIX::ApplReqType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ApplReqType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ApplReqType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ApplReqType" "', argument " "1"" of type '" "FIX::ApplReqType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ApplReqType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ApplReqType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ApplReqType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Country__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Country *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Country")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Country *)new FIX::Country();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Country, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Country__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::COUNTRY *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Country *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Country",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__COUNTRY,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Country" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Country" "', argument " "1"" of type '" "FIX::COUNTRY const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::COUNTRY * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Country *)new FIX::Country((FIX::COUNTRY const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Country, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Country(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Country__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__COUNTRY, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Country__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Country'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Country::Country()\n"
    "    FIX::Country::Country(FIX::COUNTRY const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Country(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Country *arg1 = (FIX::Country *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Country",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Country, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Country" "', argument " "1"" of type '" "FIX::Country *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Country * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Country_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Country, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityIDSource__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingLegSecurityIDSource")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecurityIDSource *)new FIX::UnderlyingLegSecurityIDSource();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityIDSource__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingLegSecurityIDSource *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingLegSecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingLegSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingLegSecurityIDSource" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingLegSecurityIDSource *)new FIX::UnderlyingLegSecurityIDSource((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingLegSecurityIDSource, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingLegSecurityIDSource(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingLegSecurityIDSource__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingLegSecurityIDSource__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingLegSecurityIDSource'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingLegSecurityIDSource::UnderlyingLegSecurityIDSource()\n"
    "    FIX::UnderlyingLegSecurityIDSource::UnderlyingLegSecurityIDSource(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingLegSecurityIDSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingLegSecurityIDSource *arg1 = (FIX::UnderlyingLegSecurityIDSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingLegSecurityIDSource",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingLegSecurityIDSource, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingLegSecurityIDSource" "', argument " "1"" of type '" "FIX::UnderlyingLegSecurityIDSource *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingLegSecurityIDSource * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingLegSecurityIDSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingLegSecurityIDSource, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FlexProductEligibilityIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FlexProductEligibilityIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FlexProductEligibilityIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FlexProductEligibilityIndicator *)new FIX::FlexProductEligibilityIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FlexProductEligibilityIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlexProductEligibilityIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FlexProductEligibilityIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FlexProductEligibilityIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FlexProductEligibilityIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FlexProductEligibilityIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FlexProductEligibilityIndicator *)new FIX::FlexProductEligibilityIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FlexProductEligibilityIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlexProductEligibilityIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FlexProductEligibilityIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FlexProductEligibilityIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FlexProductEligibilityIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FlexProductEligibilityIndicator::FlexProductEligibilityIndicator()\n"
    "    FIX::FlexProductEligibilityIndicator::FlexProductEligibilityIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FlexProductEligibilityIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FlexProductEligibilityIndicator *arg1 = (FIX::FlexProductEligibilityIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FlexProductEligibilityIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FlexProductEligibilityIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FlexProductEligibilityIndicator" "', argument " "1"" of type '" "FIX::FlexProductEligibilityIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FlexProductEligibilityIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FlexProductEligibilityIndicator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FlexProductEligibilityIndicator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AggressorIndicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AggressorIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AggressorIndicator")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AggressorIndicator *)new FIX::AggressorIndicator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AggressorIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AggressorIndicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BOOLEAN *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::AggressorIndicator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AggressorIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__BOOLEAN,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AggressorIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AggressorIndicator" "', argument " "1"" of type '" "FIX::BOOLEAN const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::BOOLEAN * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::AggressorIndicator *)new FIX::AggressorIndicator((FIX::BOOLEAN const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__AggressorIndicator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AggressorIndicator(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_AggressorIndicator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__BOOLEAN, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AggressorIndicator__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AggressorIndicator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::AggressorIndicator::AggressorIndicator()\n"
    "    FIX::AggressorIndicator::AggressorIndicator(FIX::BOOLEAN const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_AggressorIndicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::AggressorIndicator *arg1 = (FIX::AggressorIndicator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AggressorIndicator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__AggressorIndicator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AggressorIndicator" "', argument " "1"" of type '" "FIX::AggressorIndicator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::AggressorIndicator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AggressorIndicator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__AggressorIndicator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ExecPriceAdjustment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecPriceAdjustment *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ExecPriceAdjustment")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecPriceAdjustment *)new FIX::ExecPriceAdjustment();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecPriceAdjustment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecPriceAdjustment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ExecPriceAdjustment *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ExecPriceAdjustment",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExecPriceAdjustment" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExecPriceAdjustment" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ExecPriceAdjustment *)new FIX::ExecPriceAdjustment((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ExecPriceAdjustment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ExecPriceAdjustment(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_ExecPriceAdjustment__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ExecPriceAdjustment__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExecPriceAdjustment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ExecPriceAdjustment::ExecPriceAdjustment()\n"
    "    FIX::ExecPriceAdjustment::ExecPriceAdjustment(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ExecPriceAdjustment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ExecPriceAdjustment *arg1 = (FIX::ExecPriceAdjustment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ExecPriceAdjustment",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ExecPriceAdjustment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExecPriceAdjustment" "', argument " "1"" of type '" "FIX::ExecPriceAdjustment *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ExecPriceAdjustment * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ExecPriceAdjustment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ExecPriceAdjustment, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BusinessRejectReason__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BusinessRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BusinessRejectReason")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BusinessRejectReason *)new FIX::BusinessRejectReason();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BusinessRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BusinessRejectReason__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BusinessRejectReason *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BusinessRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusinessRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BusinessRejectReason" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BusinessRejectReason *)new FIX::BusinessRejectReason((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BusinessRejectReason, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BusinessRejectReason(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BusinessRejectReason__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BusinessRejectReason__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BusinessRejectReason'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BusinessRejectReason::BusinessRejectReason()\n"
    "    FIX::BusinessRejectReason::BusinessRejectReason(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BusinessRejectReason(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BusinessRejectReason *arg1 = (FIX::BusinessRejectReason *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BusinessRejectReason",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BusinessRejectReason, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusinessRejectReason" "', argument " "1"" of type '" "FIX::BusinessRejectReason *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BusinessRejectReason * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BusinessRejectReason_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BusinessRejectReason, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TradeDate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TradeDate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeDate *)new FIX::TradeDate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeDate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LOCALMKTDATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TradeDate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TradeDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__LOCALMKTDATE,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TradeDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TradeDate" "', argument " "1"" of type '" "FIX::LOCALMKTDATE const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::LOCALMKTDATE * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TradeDate *)new FIX::TradeDate((FIX::LOCALMKTDATE const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TradeDate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TradeDate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TradeDate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__LOCALMKTDATE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TradeDate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TradeDate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TradeDate::TradeDate()\n"
    "    FIX::TradeDate::TradeDate(FIX::LOCALMKTDATE const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TradeDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TradeDate *arg1 = (FIX::TradeDate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TradeDate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TradeDate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TradeDate" "', argument " "1"" of type '" "FIX::TradeDate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TradeDate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TradeDate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TradeDate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingPutOrCall__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingPutOrCall *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingPutOrCall")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingPutOrCall *)new FIX::UnderlyingPutOrCall();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingPutOrCall, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPutOrCall__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingPutOrCall *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingPutOrCall",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingPutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingPutOrCall" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingPutOrCall *)new FIX::UnderlyingPutOrCall((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingPutOrCall, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingPutOrCall(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingPutOrCall__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingPutOrCall__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingPutOrCall'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingPutOrCall::UnderlyingPutOrCall()\n"
    "    FIX::UnderlyingPutOrCall::UnderlyingPutOrCall(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingPutOrCall(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingPutOrCall *arg1 = (FIX::UnderlyingPutOrCall *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingPutOrCall",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingPutOrCall, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingPutOrCall" "', argument " "1"" of type '" "FIX::UnderlyingPutOrCall *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingPutOrCall * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingPutOrCall_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingPutOrCall, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyRole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingInstrumentPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_UnderlyingInstrumentPartyRole")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingInstrumentPartyRole *)new FIX::UnderlyingInstrumentPartyRole();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingInstrumentPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyRole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::UnderlyingInstrumentPartyRole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UnderlyingInstrumentPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UnderlyingInstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnderlyingInstrumentPartyRole" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::UnderlyingInstrumentPartyRole *)new FIX::UnderlyingInstrumentPartyRole((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__UnderlyingInstrumentPartyRole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UnderlyingInstrumentPartyRole(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_UnderlyingInstrumentPartyRole__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UnderlyingInstrumentPartyRole__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UnderlyingInstrumentPartyRole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::UnderlyingInstrumentPartyRole::UnderlyingInstrumentPartyRole()\n"
    "    FIX::UnderlyingInstrumentPartyRole::UnderlyingInstrumentPartyRole(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_UnderlyingInstrumentPartyRole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::UnderlyingInstrumentPartyRole *arg1 = (FIX::UnderlyingInstrumentPartyRole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UnderlyingInstrumentPartyRole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__UnderlyingInstrumentPartyRole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnderlyingInstrumentPartyRole" "', argument " "1"" of type '" "FIX::UnderlyingInstrumentPartyRole *""'"); 
  }
  arg1 = reinterpret_cast< FIX::UnderlyingInstrumentPartyRole * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UnderlyingInstrumentPartyRole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__UnderlyingInstrumentPartyRole, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DerivativePositionLimit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativePositionLimit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DerivativePositionLimit")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativePositionLimit *)new FIX::DerivativePositionLimit();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativePositionLimit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePositionLimit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DerivativePositionLimit *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DerivativePositionLimit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativePositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativePositionLimit" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DerivativePositionLimit *)new FIX::DerivativePositionLimit((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DerivativePositionLimit, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DerivativePositionLimit(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DerivativePositionLimit__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DerivativePositionLimit__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DerivativePositionLimit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DerivativePositionLimit::DerivativePositionLimit()\n"
    "    FIX::DerivativePositionLimit::DerivativePositionLimit(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DerivativePositionLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DerivativePositionLimit *arg1 = (FIX::DerivativePositionLimit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DerivativePositionLimit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DerivativePositionLimit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativePositionLimit" "', argument " "1"" of type '" "FIX::DerivativePositionLimit *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DerivativePositionLimit * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DerivativePositionLimit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DerivativePositionLimit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TierCode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TierCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TierCode")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TierCode *)new FIX::TierCode();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TierCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TierCode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TierCode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TierCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TierCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TierCode" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TierCode *)new FIX::TierCode((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TierCode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TierCode(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_TierCode__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TierCode__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TierCode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::TierCode::TierCode()\n"
    "    FIX::TierCode::TierCode(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TierCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::TierCode *arg1 = (FIX::TierCode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TierCode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__TierCode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TierCode" "', argument " "1"" of type '" "FIX::TierCode *""'"); 
  }
  arg1 = reinterpret_cast< FIX::TierCode * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TierCode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__TierCode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BookingType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BookingType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BookingType")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BookingType *)new FIX::BookingType();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BookingType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BookingType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::INT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BookingType *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BookingType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__INT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BookingType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BookingType" "', argument " "1"" of type '" "FIX::INT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::INT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BookingType *)new FIX::BookingType((FIX::INT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BookingType, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BookingType(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_BookingType__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__INT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BookingType__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BookingType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::BookingType::BookingType()\n"
    "    FIX::BookingType::BookingType(FIX::INT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BookingType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::BookingType *arg1 = (FIX::BookingType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BookingType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__BookingType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BookingType" "', argument " "1"" of type '" "FIX::BookingType *""'"); 
  }
  arg1 = reinterpret_cast< FIX::BookingType * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BookingType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__BookingType, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StipulationValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StipulationValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StipulationValue")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StipulationValue *)new FIX::StipulationValue();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StipulationValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StipulationValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::STRING *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::StipulationValue *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StipulationValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__STRING,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StipulationValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StipulationValue" "', argument " "1"" of type '" "FIX::STRING const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::STRING * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::StipulationValue *)new FIX::StipulationValue((FIX::STRING const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__StipulationValue, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StipulationValue(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_StipulationValue__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__STRING, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StipulationValue__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StipulationValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::StipulationValue::StipulationValue()\n"
    "    FIX::StipulationValue::StipulationValue(FIX::STRING const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_StipulationValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::StipulationValue *arg1 = (FIX::StipulationValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StipulationValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__StipulationValue, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StipulationValue" "', argument " "1"" of type '" "FIX::StipulationValue *""'"); 
  }
  arg1 = reinterpret_cast< FIX::StipulationValue * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StipulationValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__StipulationValue, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SettlCurrBidFxRate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlCurrBidFxRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SettlCurrBidFxRate")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlCurrBidFxRate *)new FIX::SettlCurrBidFxRate();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlCurrBidFxRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrBidFxRate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FLOAT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SettlCurrBidFxRate *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SettlCurrBidFxRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__FLOAT,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SettlCurrBidFxRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SettlCurrBidFxRate" "', argument " "1"" of type '" "FIX::FLOAT const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::FLOAT * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SettlCurrBidFxRate *)new FIX::SettlCurrBidFxRate((FIX::FLOAT const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SettlCurrBidFxRate, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SettlCurrBidFxRate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SettlCurrBidFxRate__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__FLOAT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SettlCurrBidFxRate__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SettlCurrBidFxRate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SettlCurrBidFxRate::SettlCurrBidFxRate()\n"
    "    FIX::SettlCurrBidFxRate::SettlCurrBidFxRate(FIX::FLOAT const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SettlCurrBidFxRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SettlCurrBidFxRate *arg1 = (FIX::SettlCurrBidFxRate *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SettlCurrBidFxRate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SettlCurrBidFxRate, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SettlCurrBidFxRate" "', argument " "1"" of type '" "FIX::SettlCurrBidFxRate *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SettlCurrBidFxRate * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SettlCurrBidFxRate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SettlCurrBidFxRate, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN int Swig_var_BeginString_FIXT11_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BeginString_FIXT11 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BeginString_FIXT11_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIXT11);
  return pyobj;
}


SWIGINTERN int Swig_var_BeginString_FIX50_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BeginString_FIX50 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BeginString_FIX50_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX50);
  return pyobj;
}


SWIGINTERN int Swig_var_BeginString_FIX44_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BeginString_FIX44 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BeginString_FIX44_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX44);
  return pyobj;
}


SWIGINTERN int Swig_var_BeginString_FIX43_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BeginString_FIX43 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BeginString_FIX43_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX43);
  return pyobj;
}


SWIGINTERN int Swig_var_BeginString_FIX42_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BeginString_FIX42 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BeginString_FIX42_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX42);
  return pyobj;
}


SWIGINTERN int Swig_var_BeginString_FIX41_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BeginString_FIX41 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BeginString_FIX41_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX41);
  return pyobj;
}


SWIGINTERN int Swig_var_BeginString_FIX40_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BeginString_FIX40 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BeginString_FIX40_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BeginString_FIX40);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INVALID_TAG_NUMBER_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_INVALID_TAG_NUMBER_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_REQUIRED_TAG_MISSING_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_REQUIRED_TAG_MISSING_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_UNDEFINED_TAG_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_UNDEFINED_TAG_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_UNDEFINED_TAG_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_UNDEFINED_TAG_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_VALUE_IS_INCORRECT_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_VALUE_IS_INCORRECT_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_DECRYPTION_PROBLEM_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_DECRYPTION_PROBLEM_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_SIGNATURE_PROBLEM_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_SIGNATURE_PROBLEM_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_COMPID_PROBLEM_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_COMPID_PROBLEM_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_COMPID_PROBLEM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_COMPID_PROBLEM_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INVALID_MSGTYPE_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INVALID_MSGTYPE_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INVALID_MSGTYPE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_INVALID_MSGTYPE_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_OTHER_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_OTHER_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_OTHER_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_OTHER_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_UNKNOWN_ID_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKNOWN_ID_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_UNKNOWN_ID_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNKNOWN_ID_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKNOWN_SECURITY_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNKNOWN_SECURITY_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_NOT_AUTHORIZED_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_NOT_AUTHORIZED_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_NOT_AUTHORIZED_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_NOT_AUTHORIZED_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryForm_BOOKENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryForm_BOOKENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryForm_BOOKENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryForm_BOOKENTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryForm_BEARER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryForm_BEARER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryForm_BEARER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryForm_BEARER));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryForm_BOOK_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryForm_BOOK_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryForm_BOOK_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryForm_BOOK_ENTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_WAREHOUSE_RECAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_WAREHOUSE_RECAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_WAREHOUSE_RECAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_WAREHOUSE_RECAP));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_GT_CORPORATE_ACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_GT_CORPORATE_ACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_GT_CORPORATE_ACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_GT_CORPORATE_ACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_PEG_REFRESH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_PEG_REFRESH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_PEG_REFRESH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_PEG_REFRESH));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_CANCELED_NOT_BEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CANCELED_NOT_BEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_CANCELED_NOT_BEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCELED_NOT_BEST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_CANCEL_ON_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_CANCEL_ON_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_CANCEL_ON_TRADING_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_CANCEL_ON_TRADING_HALT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_VERBAL_CHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_VERBAL_CHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_VERBAL_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_VERBAL_CHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_BROKER_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_BROKER_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_BROKER_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_BROKER_OPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_REPRICING_OF_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_REPRICING_OF_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_REPRICING_OF_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_REPRICING_OF_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecRestatementReason_GT_RENEWAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecRestatementReason_GT_RENEWAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecRestatementReason_GT_RENEWAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExecRestatementReason_GT_RENEWAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocIntermedReqType_PENDING_RELEASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocIntermedReqType_PENDING_RELEASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocIntermedReqType_PENDING_RELEASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_RELEASE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocIntermedReqType_PENDING_REVERSAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocIntermedReqType_PENDING_REVERSAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocIntermedReqType_PENDING_REVERSAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_REVERSAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocIntermedReqType_ACCOUNT_LEVEL_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocIntermedReqType_ACCOUNT_LEVEL_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocIntermedReqType_ACCOUNT_LEVEL_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_ACCOUNT_LEVEL_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocIntermedReqType_BLOCK_LEVEL_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocIntermedReqType_BLOCK_LEVEL_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocIntermedReqType_BLOCK_LEVEL_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_BLOCK_LEVEL_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocIntermedReqType_PENDING_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocIntermedReqType_PENDING_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocIntermedReqType_PENDING_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_PENDING_ACCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocIntermedReqType_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocIntermedReqType_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocIntermedReqType_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocIntermedReqType_ACCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListTypeSource_GICS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListTypeSource_GICS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListTypeSource_GICS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_GICS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListTypeSource_NAICS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListTypeSource_NAICS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListTypeSource_NAICS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_NAICS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListTypeSource_ICB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListTypeSource_ICB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListTypeSource_ICB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListTypeSource_ICB));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_OUTSTANDING_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_OUTSTANDING_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_OUTSTANDING_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_OUTSTANDING_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_PARTIALLY_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_PARTIALLY_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_PARTIALLY_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_PARTIALLY_ASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_TRADE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_TRADE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_TRADE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_TRADE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_FULLY_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_FULLY_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_FULLY_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_FULLY_ASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_SUBSTITUTION_ELIGIBLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_SUBSTITUTION_ELIGIBLE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_NOT_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_NOT_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_NOT_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_NOT_ASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_COLLATERAL_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_COLLATERAL_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_COLLATERAL_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_COLLATERAL_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_TRADEDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_TRADEDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_TRADEDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_TRADEDATE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_COLLATERALINSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_COLLATERALINSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_COLLATERALINSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_COLLATERALINSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryQualifier_GC_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryQualifier_GC_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryQualifier_GC_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryQualifier_GC_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContingencyType_ONE_UPDATES_THE_OTHER_4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContingencyType_ONE_UPDATES_THE_OTHER_4));
  return pyobj;
}


SWIGINTERN int Swig_var_ContingencyType_ONE_TRIGGERS_THE_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContingencyType_ONE_TRIGGERS_THE_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContingencyType_ONE_TRIGGERS_THE_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContingencyType_ONE_TRIGGERS_THE_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_ContingencyType_ONE_CANCELS_THE_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContingencyType_ONE_CANCELS_THE_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContingencyType_ONE_CANCELS_THE_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContingencyType_ONE_CANCELS_THE_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContingencyType_ONE_UPDATES_THE_OTHER_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContingencyType_ONE_UPDATES_THE_OTHER_3));
  return pyobj;
}


SWIGINTERN int Swig_var_EmailType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EmailType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EmailType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::EmailType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_EmailType_REPLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EmailType_REPLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EmailType_REPLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::EmailType_REPLY));
  return pyobj;
}


SWIGINTERN int Swig_var_EmailType_ADMIN_REPLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EmailType_ADMIN_REPLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EmailType_ADMIN_REPLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::EmailType_ADMIN_REPLY));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQltyInd_MEDIUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQltyInd_MEDIUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQltyInd_MEDIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_MEDIUM));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQltyInd_HIGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQltyInd_HIGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQltyInd_HIGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_HIGH));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQltyInd_LOW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQltyInd_LOW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQltyInd_LOW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQltyInd_LOW));
  return pyobj;
}


SWIGINTERN int Swig_var_MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_HOUSE_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_HOUSE_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_HOUSE_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_HOUSE_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_FLOOR_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_FLOOR_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_FLOOR_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_FLOOR_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_JOINT_BACK_OFFICE_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_JOINT_BACK_OFFICE_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_JOINT_BACK_OFFICE_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_JOINT_BACK_OFFICE_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_JOINT_BACKOFFICE_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_JOINT_BACKOFFICE_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_JOINT_BACKOFFICE_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_JOINT_BACKOFFICE_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonInt_ADDITIONAL_INFORMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonInt_ADDITIONAL_INFORMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonInt_ADDITIONAL_INFORMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ADDITIONAL_INFORMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonInt_NEWS_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonInt_NEWS_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonInt_NEWS_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_NEWS_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonInt_ORDER_INFLUX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonInt_ORDER_INFLUX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonInt_ORDER_INFLUX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ORDER_INFLUX));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonInt_NEWS_DISSEMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonInt_NEWS_DISSEMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonInt_NEWS_DISSEMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_NEWS_DISSEMINATION));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonInt_EQUIPMENT_CHANGEOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonInt_EQUIPMENT_CHANGEOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonInt_EQUIPMENT_CHANGEOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_EQUIPMENT_CHANGEOVER));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonInt_ORDER_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonInt_ORDER_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonInt_ORDER_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::HaltReasonInt_ORDER_IMBALANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_106H_AND_106J_FIRMS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_106H_AND_106J_FIRMS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_106H_AND_106J_FIRMS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_106H_AND_106J_FIRMS);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_LESSEE_106F_EMPLOYEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_LESSEE_106F_EMPLOYEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_LESSEE_106F_EMPLOYEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_LESSEE_106F_EMPLOYEES);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_CBOE_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_CBOE_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_CBOE_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_CBOE_MEMBER);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_6TH_YEAR_AND_BEYOND_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_6TH_YEAR_AND_BEYOND_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_6TH_YEAR_AND_BEYOND_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_6TH_YEAR_AND_BEYOND_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_BidType_DISCLOSED_STYLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidType_DISCLOSED_STYLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidType_DISCLOSED_STYLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidType_DISCLOSED_STYLE));
  return pyobj;
}


SWIGINTERN int Swig_var_BidType_NO_BIDDING_PROCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidType_NO_BIDDING_PROCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidType_NO_BIDDING_PROCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidType_NO_BIDDING_PROCESS));
  return pyobj;
}


SWIGINTERN int Swig_var_BidType_DISCLOSED_SYTLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidType_DISCLOSED_SYTLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidType_DISCLOSED_SYTLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidType_DISCLOSED_SYTLE));
  return pyobj;
}


SWIGINTERN int Swig_var_BidType_NON_DISCLOSED_STYLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidType_NON_DISCLOSED_STYLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidType_NON_DISCLOSED_STYLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidType_NON_DISCLOSED_STYLE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PER_SHARE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PER_SHARE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PER_SHARE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PER_SHARE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_YIELD));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PREMIUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PREMIUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PREMIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PREMIUM));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_TED_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_TED_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_TED_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_TED_YIELD));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_FIXED_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_FIXED_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_FIXED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_FIXED_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_DISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_DISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_DISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_DISCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_YIELD_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_YIELD_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_YIELD_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_YIELD_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_TED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_TED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_TED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_TED_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_QuotePriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuotePriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuotePriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuotePriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegPriceMethod_REVERSED_NET_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegPriceMethod_REVERSED_NET_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegPriceMethod_REVERSED_NET_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_REVERSED_NET_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegPriceMethod_MULTIPLIED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegPriceMethod_MULTIPLIED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegPriceMethod_MULTIPLIED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_MULTIPLIED_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegPriceMethod_INDIVIDUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegPriceMethod_INDIVIDUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegPriceMethod_INDIVIDUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_INDIVIDUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegPriceMethod_YIELD_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegPriceMethod_YIELD_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegPriceMethod_YIELD_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_YIELD_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegPriceMethod_NET_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegPriceMethod_NET_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegPriceMethod_NET_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegPriceMethod_NET_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ListMethod_PRE_LISTED_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListMethod_PRE_LISTED_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListMethod_PRE_LISTED_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListMethod_PRE_LISTED_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_ListMethod_USER_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListMethod_USER_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListMethod_USER_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListMethod_USER_REQUESTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDImplicitDelete_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDImplicitDelete_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDImplicitDelete_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDImplicitDelete_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_MDImplicitDelete_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDImplicitDelete_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDImplicitDelete_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDImplicitDelete_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_RoutingType_TARGET_LIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoutingType_TARGET_LIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoutingType_TARGET_LIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGET_LIST));
  return pyobj;
}


SWIGINTERN int Swig_var_RoutingType_TARGET_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoutingType_TARGET_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoutingType_TARGET_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_TARGET_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_RoutingType_BLOCK_LIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoutingType_BLOCK_LIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoutingType_BLOCK_LIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCK_LIST));
  return pyobj;
}


SWIGINTERN int Swig_var_RoutingType_BLOCK_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoutingType_BLOCK_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoutingType_BLOCK_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RoutingType_BLOCK_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_BidTradeType_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidTradeType_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidTradeType_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_AGENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_BidTradeType_VWAP_GUARANTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidTradeType_VWAP_GUARANTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidTradeType_VWAP_GUARANTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_VWAP_GUARANTEE));
  return pyobj;
}


SWIGINTERN int Swig_var_BidTradeType_RISK_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidTradeType_RISK_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidTradeType_RISK_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_RISK_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_BidTradeType_GUARANTEED_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidTradeType_GUARANTEED_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidTradeType_GUARANTEED_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidTradeType_GUARANTEED_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_INCORRECT_ALLOCATED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_INCORRECT_ALLOCATED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_INCORRECT_ALLOCATED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INCORRECT_ALLOCATED_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_ORDER_EXCEEDS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_ORDER_EXCEEDS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_ORDER_EXCEEDS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_ORDER_EXCEEDS_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_EXCHANGE_CLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_EXCHANGE_CLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_EXCHANGE_CLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_EXCHANGE_CLOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_SURVEILLENCE_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_SURVEILLENCE_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_SURVEILLENCE_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_SURVEILLENCE_OPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_UNKNOWN_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_UNKNOWN_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_UNKNOWN_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_DUPLICATE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_DUPLICATE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_DUPLICATE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_DUPLICATE_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_TOO_LATE_TO_ENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_TOO_LATE_TO_ENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_TOO_LATE_TO_ENTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_TOO_LATE_TO_ENTER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC12_SURVEILLENCE_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC12_SURVEILLENCE_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC12_SURVEILLENCE_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC12_SURVEILLENCE_OPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_INCORRECT_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_INCORRECT_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_INCORRECT_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INCORRECT_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_INVALID_PRICE_INCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_INVALID_PRICE_INCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_INVALID_PRICE_INCREMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INVALID_PRICE_INCREMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_UNKNOWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_UNKNOWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_UNKNOWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_INVALID_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_INVALID_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_INVALID_INVESTOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_INVALID_INVESTOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_BROKER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_BROKER_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_BROKER_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_BROKER_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_BROKER_OPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_TRADE_ALONG_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_TRADE_ALONG_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_TRADE_ALONG_REQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_TRADE_ALONG_REQUIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdRejReason_STALE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdRejReason_STALE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdRejReason_STALE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrdRejReason_STALE_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_MaturityMonthYearIncrementUnits_WEEKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearIncrementUnits_WEEKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MaturityMonthYearIncrementUnits_WEEKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_WEEKS));
  return pyobj;
}


SWIGINTERN int Swig_var_MaturityMonthYearIncrementUnits_MONTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearIncrementUnits_MONTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MaturityMonthYearIncrementUnits_MONTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_MONTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_MaturityMonthYearIncrementUnits_YEARS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearIncrementUnits_YEARS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MaturityMonthYearIncrementUnits_YEARS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_YEARS));
  return pyobj;
}


SWIGINTERN int Swig_var_MaturityMonthYearIncrementUnits_DAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearIncrementUnits_DAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MaturityMonthYearIncrementUnits_DAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearIncrementUnits_DAYS));
  return pyobj;
}


SWIGINTERN int Swig_var_DisplayWhen_EXHAUST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayWhen_EXHAUST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisplayWhen_EXHAUST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayWhen_EXHAUST));
  return pyobj;
}


SWIGINTERN int Swig_var_DisplayWhen_IMMEDIATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayWhen_IMMEDIATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisplayWhen_IMMEDIATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayWhen_IMMEDIATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueAction_END_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueAction_END_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueAction_END_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_END_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueAction_QUEUE_FLUSHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueAction_QUEUE_FLUSHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueAction_QUEUE_FLUSHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_QUEUE_FLUSHED));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueAction_OVERLAY_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueAction_OVERLAY_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueAction_OVERLAY_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_OVERLAY_LAST));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueAction_NO_ACTION_TAKEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueAction_NO_ACTION_TAKEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueAction_NO_ACTION_TAKEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueAction_NO_ACTION_TAKEN));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_HALFS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_HALFS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_HALFS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_HALFS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PER_SHARE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PER_SHARE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PER_SHARE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PER_SHARE));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_FOURTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_FOURTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_FOURTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_FOURTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_YIELD));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_TED_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_TED_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_TED_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_TED_YIELD));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PREMIUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PREMIUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PREMIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PREMIUM));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_FIXED_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_FIXED_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_FIXED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_FIXED_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_DISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_DISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_DISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_DISCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_EIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_EIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_EIGHTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_EIGHTS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTEENTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PRODUCT_TICKS_IN_SIXTEENTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTEENTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PRODUCT_TICKS_IN_SIXTEENTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_PER_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_PER_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_PER_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_PER_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_VARIABLE_CABINET_TRADE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_VARIABLE_CABINET_TRADE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_VARIABLE_CABINET_TRADE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_VARIABLE_CABINET_TRADE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_TED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_TED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_TED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_TED_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_FIXED_CABINET_TRADE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_FIXED_CABINET_TRADE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_FIXED_CABINET_TRADE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_FIXED_CABINET_TRADE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligMode_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligMode_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligMode_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlObligMode_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligMode_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligMode_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligMode_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlObligMode_FINAL));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityUpdateAction_DELETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityUpdateAction_DELETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityUpdateAction_DELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_DELETE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityUpdateAction_ADD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityUpdateAction_ADD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityUpdateAction_ADD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_ADD));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityUpdateAction_MODIFY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityUpdateAction_MODIFY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityUpdateAction_MODIFY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SecurityUpdateAction_MODIFY));
  return pyobj;
}


SWIGINTERN int Swig_var_NetworkRequestType_STOP_SUBSCRIBING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkRequestType_STOP_SUBSCRIBING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetworkRequestType_STOP_SUBSCRIBING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_STOP_SUBSCRIBING));
  return pyobj;
}


SWIGINTERN int Swig_var_NetworkRequestType_SUBSCRIBE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkRequestType_SUBSCRIBE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetworkRequestType_SUBSCRIBE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_SUBSCRIBE));
  return pyobj;
}


SWIGINTERN int Swig_var_NetworkRequestType_SNAPSHOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkRequestType_SNAPSHOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetworkRequestType_SNAPSHOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_SNAPSHOT));
  return pyobj;
}


SWIGINTERN int Swig_var_NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXECUTION_VENUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXECUTION_VENUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXECUTION_VENUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTION_VENUE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CLIENT_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CLIENT_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CLIENT_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLIENT_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_MARKET_DATA_ENTRY_ORIGINATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_MARKET_DATA_ENTRY_ORIGINATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_MARKET_DATA_ENTRY_ORIGINATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_MARKET_DATA_ENTRY_ORIGINATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ORDER_ORIGINATION_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ORDER_ORIGINATION_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ORDER_ORIGINATION_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ORDER_ORIGINATION_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_PLEDGEE_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_PLEDGEE_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_PLEDGEE_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_PLEDGEE_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CONTRA_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CONTRA_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_MULTILATERAL_TRADING_FACILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_MULTILATERAL_TRADING_FACILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_MULTILATERAL_TRADING_FACILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_MULTILATERAL_TRADING_FACILITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CENTRAL_REGISTRATION_DEPOSITORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CENTRAL_REGISTRATION_DEPOSITORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CENTRAL_REGISTRATION_DEPOSITORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CENTRAL_REGISTRATION_DEPOSITORY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_REPORT_ORIGINATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_REPORT_ORIGINATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_REPORT_ORIGINATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REPORT_ORIGINATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_TRANSFER_TO_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_TRANSFER_TO_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_TRANSFER_TO_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_TRANSFER_TO_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_BROKERCLEARINGID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_BROKERCLEARINGID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_BROKERCLEARINGID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BROKERCLEARINGID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ASSET_MANAGER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ASSET_MANAGER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ASSET_MANAGER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ASSET_MANAGER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INTRODUCING_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INTRODUCING_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INTRODUCING_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTRODUCING_BROKER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_LOCATE_LENDING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_LOCATE_LENDING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_LOCATE_LENDING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LOCATE_LENDING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CONTRA_CLEARING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_CLEARING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CONTRA_CLEARING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_CLEARING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CUSTODIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CUSTODIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CUSTODIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CUSTODIAN));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_GIVEUP_CLEARING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_GIVEUP_CLEARING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_GIVEUP_CLEARING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_GIVEUP_CLEARING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXECUTING_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXECUTING_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXECUTING_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXECUTING_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXECUTING_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXECUTING_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_BROKER_OF_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_BROKER_OF_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_BROKER_OF_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BROKER_OF_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CORRESPONDANT_CLEARING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CORRESPONDANT_CLEARING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CORRESPONDANT_CLEARING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDANT_CLEARING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SETTLEMENT_LOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SETTLEMENT_LOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SETTLEMENT_LOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SETTLEMENT_LOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_THIRD_PARTY_ALLOCATION_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_THIRD_PARTY_ALLOCATION_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_THIRD_PARTY_ALLOCATION_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_THIRD_PARTY_ALLOCATION_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ORDER_ORIGINATION_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ORDER_ORIGINATION_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ORDER_ORIGINATION_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ORDER_ORIGINATION_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_HOST_COMPETENT_AUTHORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_HOST_COMPETENT_AUTHORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_HOST_COMPETENT_AUTHORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_HOST_COMPETENT_AUTHORITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ORDER_ENTRY_OPERATOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ORDER_ENTRY_OPERATOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ORDER_ENTRY_OPERATOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ORDER_ENTRY_OPERATOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SPONSORING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SPONSORING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SPONSORING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SPONSORING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INTRODUCING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INTRODUCING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INTRODUCING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTRODUCING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CLEARING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CLEARING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CLEARING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CONTRA_POSITION_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_POSITION_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CONTRA_POSITION_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_POSITION_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INVESTOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INVESTOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ENTERING_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ENTERING_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ENTERING_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_LOCATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_LOCATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_LOCATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LOCATE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_FORIEGN_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_FORIEGN_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_FORIEGN_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_FORIEGN_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ACCEPTABLE_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ACCEPTABLE_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ACCEPTABLE_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ACCEPTABLE_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CUSTOMER_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CUSTOMER_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CUSTOMER_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CUSTOMER_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_POSITION_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_POSITION_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_POSITION_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_POSITION_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_LIQUIDITY_PROVIDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_LIQUIDITY_PROVIDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_LIQUIDITY_PROVIDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LIQUIDITY_PROVIDER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_AGENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ENTERING_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ENTERING_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ENTERING_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_FOREIGN_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_FOREIGN_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_FOREIGN_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_FOREIGN_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CLEARING_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CLEARING_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CLEARING_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_HOME_COMPETENT_AUTHORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_HOME_COMPETENT_AUTHORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_HOME_COMPETENT_AUTHORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_HOME_COMPETENT_AUTHORITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INTERESTED_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INTERESTED_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INTERESTED_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERESTED_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SESSION_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SESSION_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SESSION_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SESSION_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_REPORTING_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_REPORTING_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_REPORTING_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REPORTING_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INVESTMENT_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INVESTMENT_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INVESTMENT_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INVESTMENT_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_TRADER_MNEMONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_TRADER_MNEMONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_TRADER_MNEMONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_TRADER_MNEMONIC));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INTERNAL_CARRY_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INTERNAL_CARRY_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INTERNAL_CARRY_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERNAL_CARRY_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CONTRA_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CONTRA_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CORRESPONDENT_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CORRESPONDENT_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CORRESPONDENT_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CORRESPONDENT_BROKER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CLEARING_ORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CLEARING_ORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CLEARING_ORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLEARING_ORGANIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SUB_CUSTODIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SUB_CUSTODIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SUB_CUSTODIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SUB_CUSTODIAN));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_BUYER_SELLER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_BUYER_SELLER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_BUYER_SELLER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BUYER_SELLER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_STEP_OUT_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_STEP_OUT_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_STEP_OUT_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_STEP_OUT_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_MARKET_DATA_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_MARKET_DATA_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_MARKET_DATA_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_MARKET_DATA_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CLAIMING_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CLAIMING_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CLAIMING_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CLAIMING_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SECONDARY_ACCOUNT_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SECONDARY_ACCOUNT_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SECONDARY_ACCOUNT_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SECONDARY_ACCOUNT_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ALLOCATION_ENTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ALLOCATION_ENTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ALLOCATION_ENTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ALLOCATION_ENTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXECUTING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXECUTING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXECUTING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_LOCATION_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_LOCATION_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_LOCATION_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_LOCATION_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_DESK_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_DESK_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_DESK_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_DESK_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_EXECUTING_SYSTEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_EXECUTING_SYSTEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_EXECUTING_SYSTEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_EXECUTING_SYSTEM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_BENEFICIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_BENEFICIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_BENEFICIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_BENEFICIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_FUND_MANAGER_CLIENT_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_FUND_MANAGER_CLIENT_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_FUND_MANAGER_CLIENT_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_FUND_MANAGER_CLIENT_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CONTRA_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CONTRA_INVESTOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_INVESTOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_UNACCEPTABLE_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_UNACCEPTABLE_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_UNACCEPTABLE_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_UNACCEPTABLE_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_UNDERLYING_CONTRA_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_UNDERLYING_CONTRA_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_UNDERLYING_CONTRA_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_UNDERLYING_CONTRA_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_QUOTE_ORIGINATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_QUOTE_ORIGINATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_QUOTE_ORIGINATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_QUOTE_ORIGINATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_REGULATED_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_REGULATED_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_REGULATED_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REGULATED_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_ENTERING_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_ENTERING_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_ENTERING_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_ENTERING_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SENDER_LOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SENDER_LOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SENDER_LOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SENDER_LOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_SYSTEMATIC_INTERNALISER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_SYSTEMATIC_INTERNALISER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_SYSTEMATIC_INTERNALISER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_SYSTEMATIC_INTERNALISER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_CONTRA_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_CONTRA_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_CONTRA_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_CONTRA_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_REGULATORY_BODY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_REGULATORY_BODY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_REGULATORY_BODY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_REGULATORY_BODY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_PLEDGOR_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_PLEDGOR_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_PLEDGOR_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_PLEDGOR_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY));
  return pyobj;
}


SWIGINTERN int Swig_var_AssignmentMethod_PRO_RATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssignmentMethod_PRO_RATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssignmentMethod_PRO_RATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AssignmentMethod_PRO_RATA));
  return pyobj;
}


SWIGINTERN int Swig_var_AssignmentMethod_RANDOM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssignmentMethod_RANDOM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssignmentMethod_RANDOM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AssignmentMethod_RANDOM));
  return pyobj;
}


SWIGINTERN int Swig_var_AssignmentMethod_PRORATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AssignmentMethod_PRORATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AssignmentMethod_PRORATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AssignmentMethod_PRORATA));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_TZTIMEONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_TZTIMEONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_TZTIMEONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TZTIMEONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_MONTHYEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_MONTHYEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_MONTHYEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MONTHYEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_QTY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_BOOLEAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_BOOLEAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_BOOLEAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_BOOLEAN));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_MULTIPLECHARVALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_MULTIPLECHARVALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_MULTIPLECHARVALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MULTIPLECHARVALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_CHAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_CHAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_CHAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_CHAR));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_NUMINGROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_NUMINGROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_NUMINGROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_NUMINGROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_TAGNUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_TAGNUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_TAGNUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TAGNUM));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_COUNTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_COUNTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_COUNTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_COUNTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_TENOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_TENOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_TENOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TENOR));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_LOCALMKTTIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_LOCALMKTTIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_LOCALMKTTIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LOCALMKTTIME));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_INT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_INT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_INT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_INT));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_LOCALMKTDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_LOCALMKTDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_LOCALMKTDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LOCALMKTDATE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_LANGUAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_LANGUAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_LANGUAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LANGUAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_LENGTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_LENGTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_LENGTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_LENGTH));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_TZTIMESTAMP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_TZTIMESTAMP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_TZTIMESTAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_TZTIMESTAMP));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_MULTIPLESTRINGVALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_MULTIPLESTRINGVALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_MULTIPLESTRINGVALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_MULTIPLESTRINGVALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_UTCTIMESTAMP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_UTCTIMESTAMP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_UTCTIMESTAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCTIMESTAMP));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_DATA));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_CURRENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_STRING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_STRING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_STRING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_STRING));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_AMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_AMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_AMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_AMT));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_FLOAT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_FLOAT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_FLOAT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_FLOAT));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_UTCDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_UTCDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_UTCDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCDATE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_UTCTIMEONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_UTCTIMEONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_UTCTIMEONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCTIMEONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_SEQNUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_SEQNUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_SEQNUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_SEQNUM));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_UTCDATEONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_UTCDATEONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_UTCDATEONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_UTCDATEONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrategyParameterType_PRICEOFFSET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrategyParameterType_PRICEOFFSET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrategyParameterType_PRICEOFFSET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrategyParameterType_PRICEOFFSET));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_PGP_DES_MD5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_PGP_DES_MD5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_PGP_DES_MD5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PGP_DES_MD5));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_PKCS_DES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_PKCS_DES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_PKCS_DES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PKCS_DES));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_PKCS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_PKCS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_PKCS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PKCS));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_PGP_DES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_PGP_DES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_PGP_DES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PGP_DES));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_DES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_DES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_DES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_DES));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_NONE_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_NONE_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_NONE_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_NONE_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_EncryptMethod_PEM_DES_MD5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EncryptMethod_PEM_DES_MD5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EncryptMethod_PEM_DES_MD5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EncryptMethod_PEM_DES_MD5));
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_ACCRUED_COUPON_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_ACCRUED_COUPON_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_ACCRUED_COUPON_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_ACCRUED_COUPON_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_PREMIUM_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_PREMIUM_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_PREMIUM_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_PREMIUM_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_TOTAL_BANKED_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_TOTAL_BANKED_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_TOTAL_BANKED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_TOTAL_BANKED_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_SETTLEMENT_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_SETTLEMENT_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_SETTLEMENT_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_SETTLEMENT_VALUE);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_CASH_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_CASH_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_CASH_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_CASH_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_INITIAL_TRADE_COUPON_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_INITIAL_TRADE_COUPON_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_INCREMENTAL_ACCRUED_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_INCREMENTAL_ACCRUED_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_INCREMENTAL_ACCRUED_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_INCREMENTAL_ACCRUED_COUPON);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_VALUE_ADJUSTED_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_VALUE_ADJUSTED_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_VALUE_ADJUSTED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_VALUE_ADJUSTED_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_COLLATERALIZED_MARK_TO_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_COLLATERALIZED_MARK_TO_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_COLLATERALIZED_MARK_TO_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_COLLATERALIZED_MARK_TO_MARKET);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_CASH_RESIDUAL_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_CASH_RESIDUAL_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_CASH_RESIDUAL_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_CASH_RESIDUAL_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_COMPENSATION_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_COMPENSATION_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_COMPENSATION_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_COMPENSATION_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_TRADE_VARIATION_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_TRADE_VARIATION_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_TRADE_VARIATION_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_TRADE_VARIATION_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_COUPON_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_COUPON_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_COUPON_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_COUPON_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_TOTAL_COLLATERALIZED_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_TOTAL_COLLATERALIZED_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_ResetSeqNumFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResetSeqNumFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ResetSeqNumFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ResetSeqNumFlag_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_ResetSeqNumFlag_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResetSeqNumFlag_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ResetSeqNumFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ResetSeqNumFlag_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_INVALID_DESTINATION_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_INVALID_DESTINATION_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_INVALID_DESTINATION_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_DESTINATION_REQUESTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_INVALID_PARTIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_INVALID_PARTIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_INVALID_PARTIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_PARTIES));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRespType_DECLINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRespType_DECLINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRespType_DECLINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_DECLINED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRespType_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRespType_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRespType_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRespType_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRespType_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRespType_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRespType_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRespType_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRespType_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRespType_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_UnsolicitedIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnsolicitedIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnsolicitedIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::UnsolicitedIndicator_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_UnsolicitedIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnsolicitedIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnsolicitedIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::UnsolicitedIndicator_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_INVALID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_INVALID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_INVALID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_INVALID_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_TOO_LATE_TO_ENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_TOO_LATE_TO_ENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_TOO_LATE_TO_ENTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_TOO_LATE_TO_ENTER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_UNKNOWN_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_UNKNOWN_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_UNKNOWN_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_UNKNOWN_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryRejectReason_DUPLICATE_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryRejectReason_DUPLICATE_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryRejectReason_DUPLICATE_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryRejectReason_DUPLICATE_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCapacity_PROPRIETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCapacity_PROPRIETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCapacity_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_PROPRIETARY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCapacity_RISKLESS_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCapacity_RISKLESS_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCapacity_RISKLESS_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_RISKLESS_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCapacity_AGENT_FOR_OTHER_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCapacity_AGENT_FOR_OTHER_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCapacity_AGENT_FOR_OTHER_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_AGENT_FOR_OTHER_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCapacity_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCapacity_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCapacity_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCapacity_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCapacity_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCapacity_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_AGENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCapacity_INDIVIDUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCapacity_INDIVIDUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCapacity_INDIVIDUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCapacity_INDIVIDUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAckStatus_CANCELED_FOR_UNDERLYING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_CANCELED_FOR_UNDERLYING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAckStatus_CANCELED_FOR_UNDERLYING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_CANCELED_FOR_UNDERLYING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAckStatus_CANCELED_ALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_CANCELED_ALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAckStatus_CANCELED_ALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_CANCELED_ALL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAckStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAckStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAckStatus_CANCELED_FOR_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_CANCELED_FOR_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAckStatus_CANCELED_FOR_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_CANCELED_FOR_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteAckStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteAckStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteAckStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteAckStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_UserRequestType_CHANGE_PASSWORD_FOR_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_CHANGE_PASSWORD_FOR_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserRequestType_CHANGE_PASSWORD_FOR_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_CHANGE_PASSWORD_FOR_USER));
  return pyobj;
}


SWIGINTERN int Swig_var_UserRequestType_CHANGEPASSWORDFORUSER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_CHANGEPASSWORDFORUSER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserRequestType_CHANGEPASSWORDFORUSER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_CHANGEPASSWORDFORUSER));
  return pyobj;
}


SWIGINTERN int Swig_var_UserRequestType_LOGOFFUSER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_LOGOFFUSER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserRequestType_LOGOFFUSER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_LOGOFFUSER));
  return pyobj;
}


SWIGINTERN int Swig_var_UserRequestType_LOG_OFF_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_LOG_OFF_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserRequestType_LOG_OFF_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_LOG_OFF_USER));
  return pyobj;
}


SWIGINTERN int Swig_var_UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_UserRequestType_LOGONUSER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_LOGONUSER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserRequestType_LOGONUSER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_LOGONUSER));
  return pyobj;
}


SWIGINTERN int Swig_var_UserRequestType_LOG_ON_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserRequestType_LOG_ON_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserRequestType_LOG_ON_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserRequestType_LOG_ON_USER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportTransType_REVERSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportTransType_REVERSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportTransType_REVERSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_REVERSE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportTransType_RELEASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportTransType_RELEASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportTransType_RELEASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportTransType_RELEASE));
  return pyobj;
}


SWIGINTERN int Swig_var_AdvSide_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvSide_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdvSide_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AdvSide_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_AdvSide_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvSide_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdvSide_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AdvSide_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_AdvSide_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvSide_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdvSide_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AdvSide_BUY));
  return pyobj;
}


SWIGINTERN int Swig_var_AdvSide_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvSide_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdvSide_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AdvSide_SELL));
  return pyobj;
}


SWIGINTERN int Swig_var_CoveredOrUncovered_COVERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CoveredOrUncovered_COVERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CoveredOrUncovered_COVERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CoveredOrUncovered_COVERED));
  return pyobj;
}


SWIGINTERN int Swig_var_CoveredOrUncovered_UNCOVERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CoveredOrUncovered_UNCOVERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CoveredOrUncovered_UNCOVERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CoveredOrUncovered_UNCOVERED));
  return pyobj;
}


SWIGINTERN int Swig_var_AcctIDSource_TFM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AcctIDSource_TFM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AcctIDSource_TFM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_TFM));
  return pyobj;
}


SWIGINTERN int Swig_var_AcctIDSource_BIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AcctIDSource_BIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AcctIDSource_BIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_BIC));
  return pyobj;
}


SWIGINTERN int Swig_var_AcctIDSource_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AcctIDSource_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AcctIDSource_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_AcctIDSource_OMGEO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AcctIDSource_OMGEO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AcctIDSource_OMGEO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_OMGEO));
  return pyobj;
}


SWIGINTERN int Swig_var_AcctIDSource_DTCC_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AcctIDSource_DTCC_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AcctIDSource_DTCC_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_DTCC_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_AcctIDSource_SID_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AcctIDSource_SID_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AcctIDSource_SID_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AcctIDSource_SID_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestType_ALL_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestType_ALL_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestType_ALL_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_ALL_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatus_HALTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_HALTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatus_HALTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_HALTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatus_REQUEST_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_REQUEST_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatus_REQUEST_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_REQUEST_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatus_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatus_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatus_PRE_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_PRE_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatus_PRE_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_PRE_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatus_UNKNOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_UNKNOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatus_UNKNOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_UNKNOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatus_PRE_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_PRE_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatus_PRE_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_PRE_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatus_CLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatus_CLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatus_CLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatus_CLOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_LAST_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_LAST_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_LAST_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_LAST_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_PRIMARY_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_PRIMARY_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_PRIMARY_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_PRIMARY_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_OPENING_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_OPENING_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_OPENING_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_OPENING_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_TRAILING_STOP_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_TRAILING_STOP_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_TRAILING_STOP_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_TRAILING_STOP_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_PEG_TO_LIMIT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_PEG_TO_LIMIT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_PEG_TO_LIMIT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_PEG_TO_LIMIT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_MID_PRICE_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_MID_PRICE_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_MID_PRICE_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_MID_PRICE_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_MARKET_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_MARKET_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_MARKET_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_MARKET_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_PegPriceType_PEG_TO_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegPriceType_PEG_TO_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegPriceType_PEG_TO_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegPriceType_PEG_TO_VWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnRejReason_NO_AVAILABLE_STREAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnRejReason_NO_AVAILABLE_STREAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnRejReason_NO_AVAILABLE_STREAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_NO_AVAILABLE_STREAM));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnRejReason_UNKNOWN_CLIENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnRejReason_UNKNOWN_CLIENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnRejReason_UNKNOWN_CLIENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_UNKNOWN_CLIENT));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnRejReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnRejReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnRejReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_ValuationMethod_PREMIUM_STYLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValuationMethod_PREMIUM_STYLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValuationMethod_PREMIUM_STYLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ValuationMethod_PREMIUM_STYLE);
  return pyobj;
}


SWIGINTERN int Swig_var_ValuationMethod_CDS_IN_DELIVERY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValuationMethod_CDS_IN_DELIVERY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValuationMethod_CDS_IN_DELIVERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ValuationMethod_CDS_IN_DELIVERY);
  return pyobj;
}


SWIGINTERN int Swig_var_ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON);
  return pyobj;
}


SWIGINTERN int Swig_var_ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET);
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerType_SPECIFIED_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerType_SPECIFIED_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerType_SPECIFIED_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerType_SPECIFIED_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerType_NEXT_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerType_NEXT_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerType_NEXT_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerType_NEXT_AUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerType_PRICE_MOVEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerType_PRICE_MOVEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerType_PRICE_MOVEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerType_PRICE_MOVEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerType_PARTIAL_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerType_PARTIAL_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerType_PARTIAL_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerType_PARTIAL_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceProtectionScope_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceProtectionScope_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceProtectionScope_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_LOCAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceProtectionScope_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceProtectionScope_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceProtectionScope_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceProtectionScope_GLOBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceProtectionScope_GLOBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceProtectionScope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_GLOBAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceProtectionScope_NATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceProtectionScope_NATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceProtectionScope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PriceProtectionScope_NATIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_INVALID_PARTY_INFORMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_INVALID_PARTY_INFORMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_INVALID_PARTY_INFORMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_INVALID_PARTY_INFORMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_INVALID_PARTY_ONFORMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_INVALID_PARTY_ONFORMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_INVALID_PARTY_ONFORMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_INVALID_PARTY_ONFORMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_UNKNOWN_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_UNKNOWN_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_UNKNOWN_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_UNKNOWN_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportRejectReason_INVALID_TRADE_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportRejectReason_INVALID_TRADE_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportRejectReason_INVALID_TRADE_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportRejectReason_INVALID_TRADE_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListType_NEWSPAPER_LIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListType_NEWSPAPER_LIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListType_NEWSPAPER_LIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListType_NEWSPAPER_LIST));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListType_TRADING_LIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListType_TRADING_LIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListType_TRADING_LIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListType_TRADING_LIST));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListType_INDUSTRY_CLASSIFICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListType_INDUSTRY_CLASSIFICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListType_INDUSTRY_CLASSIFICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListType_INDUSTRY_CLASSIFICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListType_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListType_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListType_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListType_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_QUOTE_LOCKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_QUOTE_LOCKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_QUOTE_LOCKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_QUOTE_LOCKED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_INVALID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_INVALID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_INVALID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVALID_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_TOO_LATE_TO_ENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_TOO_LATE_TO_ENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_TOO_LATE_TO_ENTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_TOO_LATE_TO_ENTER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_INVALID_BID_ASK_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_INVALID_BID_ASK_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_INVALID_BID_ASK_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVALID_BID_ASK_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_UNKNOWN_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_UNKNOWN_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_UNKNOWN_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_UNKNOWN_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_DUPLICATE_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_DUPLICATE_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_DUPLICATE_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_DUPLICATE_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PossResend_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PossResend_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PossResend_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PossResend_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_PossResend_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PossResend_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PossResend_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PossResend_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_SHARES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_SHARES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_SHARES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_SHARES));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_CURRENTFACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_CURRENTFACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_CURRENTFACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_CURRENTFACE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_PAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_PAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_PAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_PAR));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_BONDS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_ORIGINALFACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_ORIGINALFACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_ORIGINALFACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_ORIGINALFACE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_CONTRACTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_CONTRACTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_CONTRACTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_CONTRACTS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuantityType_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuantityType_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuantityType_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuantityType_CURRENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_ImpliedMarketIndicator_NOT_IMPLIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ImpliedMarketIndicator_NOT_IMPLIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ImpliedMarketIndicator_NOT_IMPLIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_NOT_IMPLIED));
  return pyobj;
}


SWIGINTERN int Swig_var_ImpliedMarketIndicator_IMPLIED_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ImpliedMarketIndicator_IMPLIED_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ImpliedMarketIndicator_IMPLIED_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_IMPLIED_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_ImpliedMarketIndicator_IMPLIED_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ImpliedMarketIndicator_IMPLIED_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ImpliedMarketIndicator_IMPLIED_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ImpliedMarketIndicator_IMPLIED_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestType_AUTOMATIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestType_AUTOMATIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestType_AUTOMATIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_AUTOMATIC));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestType_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestType_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestType_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestType_MANUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestResult_VALID_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_VALID_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestResult_VALID_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_VALID_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_ISSUER_HOLDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ISSUER_HOLDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_ISSUER_HOLDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ISSUER_HOLDING));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_NON_ALGORITHMIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_NON_ALGORITHMIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_NON_ALGORITHMIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_NON_ALGORITHMIC));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_NON_INDEX_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_NON_INDEX_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_NON_INDEX_ARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_NON_INDEX_ARBITRAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OF_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SEUCIRTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ACTING_AS_MARKET_MAKER_OF_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SEUCIRTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OF_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SEUCIRTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ACTING_AS_MARKET_MAKER_OF_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SEUCIRTY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_PROGRAM_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_PROGRAM_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_PROGRAM_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_PROGRAM_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_ISSUE_PRICE_STABILIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ISSUE_PRICE_STABILIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_ISSUE_PRICE_STABILIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ISSUE_PRICE_STABILIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_FOREIGN_ENTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_FOREIGN_ENTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_FOREIGN_ENTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_FOREIGN_ENTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_INDEX_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_INDEX_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_INDEX_ARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_INDEX_ARBITRAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_ALGORITHMIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ALGORITHMIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_ALGORITHMIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ALGORITHMIC));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_RISKLESS_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_RISKLESS_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_RISKLESS_ARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_RISKLESS_ARBITRAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderRestrictions_COMPETING_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderRestrictions_COMPETING_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderRestrictions_COMPETING_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderRestrictions_COMPETING_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN));
  return pyobj;
}


SWIGINTERN int Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW));
  return pyobj;
}


SWIGINTERN int Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3));
  return pyobj;
}


SWIGINTERN int Swig_var_ListExecInstType_IMMEDIATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_IMMEDIATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListExecInstType_IMMEDIATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_IMMEDIATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4));
  return pyobj;
}


SWIGINTERN int Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5));
  return pyobj;
}


SWIGINTERN int Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP));
  return pyobj;
}


SWIGINTERN int Swig_var_ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_FED_WIRE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_FED_WIRE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_FED_WIRE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_FED_WIRE));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_EUROCLEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_EUROCLEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_EUROCLEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_EUROCLEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_ACH_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_ACH_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_ACH_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_ACH_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_TELEGRAPHIC_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_TELEGRAPHIC_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_TELEGRAPHIC_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_TELEGRAPHIC_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_FEDWIRE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_FEDWIRE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_FEDWIRE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_FEDWIRE));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_CHEQUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_CHEQUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_CHEQUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CHEQUE));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_DIRECT_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_DIRECT_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_DIRECT_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_DIRECT_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_CREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_CREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_CREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CREST));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_CLEARSTREAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_CLEARSTREAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_CLEARSTREAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_CLEARSTREAM));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_BPAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_BPAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_BPAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_BPAY));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_NSCC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_NSCC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_NSCC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_NSCC));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS));
  return pyobj;
}


SWIGINTERN int Swig_var_DistribPaymentMethod_REINVEST_IN_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DistribPaymentMethod_REINVEST_IN_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DistribPaymentMethod_REINVEST_IN_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DistribPaymentMethod_REINVEST_IN_FUND));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderHandlingInstSource_NASD_OATS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderHandlingInstSource_NASD_OATS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderHandlingInstSource_NASD_OATS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderHandlingInstSource_NASD_OATS));
  return pyobj;
}


SWIGINTERN int Swig_var_AffirmStatus_AFFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AffirmStatus_AFFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AffirmStatus_AFFIRMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_AFFIRMED));
  return pyobj;
}


SWIGINTERN int Swig_var_AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED));
  return pyobj;
}


SWIGINTERN int Swig_var_AffirmStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AffirmStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AffirmStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AffirmStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrigCustOrderCapacity_ALL_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrigCustOrderCapacity_ALL_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrigCustOrderCapacity_ALL_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrigCustOrderCapacity_ALL_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocMethod_GUARANTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocMethod_GUARANTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocMethod_GUARANTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocMethod_GUARANTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocMethod_AUTOMATIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocMethod_AUTOMATIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocMethod_AUTOMATIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocMethod_AUTOMATIC));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocMethod_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocMethod_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocMethod_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocMethod_MANUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ALL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ALL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ALL_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ALL_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_REQUEST_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_REQUEST_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_REQUEST_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_REQUEST_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN);
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestinationIDSource_PROPRIETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationIDSource_PROPRIETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestinationIDSource_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_PROPRIETARY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestinationIDSource_BIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationIDSource_BIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestinationIDSource_BIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_BIC));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestinationIDSource_MIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationIDSource_MIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestinationIDSource_MIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_MIC));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestinationIDSource_ISO_COUNTRY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestinationIDSource_ISO_COUNTRY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestinationIDSource_ISO_COUNTRY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestinationIDSource_ISO_COUNTRY_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListRequestType_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListRequestType_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListRequestType_TRADINGSESSIONID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_TRADINGSESSIONID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListRequestType_TRADINGSESSIONID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_TRADINGSESSIONID));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListRequestType_ALL_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_ALL_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListRequestType_ALL_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_ALL_SECURITIES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityListRequestType_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityListRequestType_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityListRequestType_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityListRequestType_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_TIME_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_TIME_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_TIME_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_TIME_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_ADVERSE_TAX_EVENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_ADVERSE_TAX_EVENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_ADVERSE_TAX_EVENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_ADVERSE_TAX_EVENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_MARGIN_DEFICIENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_MARGIN_DEFICIENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_MARGIN_DEFICIENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_MARGIN_DEFICIENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_SCHEDULED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_SCHEDULED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_SCHEDULED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_SCHEDULED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_INITIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_INITIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_INITIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_INITIAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_FORWARD_COLLATERAL_DEMAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_FORWARD_COLLATERAL_DEMAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_FORWARD_COLLATERAL_DEMAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_FORWARD_COLLATERAL_DEMAND));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_EVENT_OF_DEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_EVENT_OF_DEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_EVENT_OF_DEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_EVENT_OF_DEFAULT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnReason_MARGIN_EXCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnReason_MARGIN_EXCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnReason_MARGIN_EXCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnReason_MARGIN_EXCESS));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlPriceType_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlPriceType_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlPriceType_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlPriceType_FINAL));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlPriceType_THEORETICAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlPriceType_THEORETICAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlPriceType_THEORETICAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlPriceType_THEORETICAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DealingCapacity_RISKLESS_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DealingCapacity_RISKLESS_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DealingCapacity_RISKLESS_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_RISKLESS_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DealingCapacity_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DealingCapacity_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DealingCapacity_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DealingCapacity_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DealingCapacity_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DealingCapacity_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DealingCapacity_AGENT));
  return pyobj;
}


SWIGINTERN int Swig_var_RateSourceType_SECONDARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSourceType_SECONDARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RateSourceType_SECONDARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSourceType_SECONDARY));
  return pyobj;
}


SWIGINTERN int Swig_var_RateSourceType_PRIMARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSourceType_PRIMARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RateSourceType_PRIMARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSourceType_PRIMARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AggregatedBook_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AggregatedBook_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AggregatedBook_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AggregatedBook_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_AggregatedBook_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AggregatedBook_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AggregatedBook_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AggregatedBook_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_PosQtyStatus_SUBMITTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosQtyStatus_SUBMITTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosQtyStatus_SUBMITTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_SUBMITTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosQtyStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosQtyStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosQtyStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosQtyStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosQtyStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosQtyStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosQtyStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_TradingSessionStatusRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradingSessionStatusRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_TradingSessionStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionStatusRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_ListStatus_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ListStatus is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_ListStatus_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListStatus);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_Email_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Email is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_Email_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Email);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_ListExecute_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ListExecute is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_ListExecute_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListExecute);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_Confirmation_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Confirmation is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_Confirmation_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Confirmation);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_NewOrderMultileg_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_NewOrderMultileg is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_NewOrderMultileg_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NewOrderMultileg);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_MarketDataIncrementalRefresh_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MarketDataIncrementalRefresh is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_MarketDataIncrementalRefresh_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataIncrementalRefresh);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_TradeCaptureReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradeCaptureReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_TradeCaptureReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_RequestForPositionsAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_RequestForPositionsAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_RequestForPositionsAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RequestForPositionsAck);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_StreamAssignmentRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_StreamAssignmentRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_StreamAssignmentRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_SecurityListRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityListRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_SecurityListRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityListRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_CollateralReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CollateralReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_CollateralReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_PositionMaintenanceReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_PositionMaintenanceReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_PositionMaintenanceReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PositionMaintenanceReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_PositionReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_PositionReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_PositionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PositionReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_StreamAssignmentReportACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_StreamAssignmentReportACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_StreamAssignmentReportACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentReportACK);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_UserRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_UserRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_UserRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_UserRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_PositionMaintenanceRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_PositionMaintenanceRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_PositionMaintenanceRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_PositionMaintenanceRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_NetworkCounterpartySystemStatusResponse_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_NetworkCounterpartySystemStatusResponse is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_NetworkCounterpartySystemStatusResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NetworkCounterpartySystemStatusResponse);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_NewOrderCross_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_NewOrderCross is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_NewOrderCross_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NewOrderCross);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_AdjustedPositionReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AdjustedPositionReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_AdjustedPositionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AdjustedPositionReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_Logon_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Logon is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_Logon_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Logon);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_IOI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_IOI is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_IOI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_IOI);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_ListStrikePrice_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ListStrikePrice is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_ListStrikePrice_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListStrikePrice);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_BidRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_BidRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_BidRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_BidRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_TradingSessionStatus_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradingSessionStatus is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_TradingSessionStatus_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionStatus);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_RegistrationInstructionsResponse_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_RegistrationInstructionsResponse is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_RegistrationInstructionsResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RegistrationInstructionsResponse);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_Advertisement_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Advertisement is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_Advertisement_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Advertisement);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_MassQuote_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MassQuote is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_MassQuote_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MassQuote);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_Logout_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Logout is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_Logout_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Logout);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_AllocationReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AllocationReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_AllocationReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_SecurityDefinitionUpdateReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityDefinitionUpdateReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_SecurityDefinitionUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinitionUpdateReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_ListStatusRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ListStatusRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_ListStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListStatusRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_BusinessMessageReject_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_BusinessMessageReject is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_BusinessMessageReject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_BusinessMessageReject);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_ConfirmationAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ConfirmationAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_ConfirmationAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ConfirmationAck);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_XMLnonFIX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_XMLnonFIX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_XMLnonFIX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_XMLnonFIX);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_TestRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TestRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_TestRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TestRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_SecurityList_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityList is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_SecurityList_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityList);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_ListCancelRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ListCancelRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_ListCancelRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ListCancelRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_News_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_News is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_News_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_News);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_TradingSessionListUpdateReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradingSessionListUpdateReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_TradingSessionListUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionListUpdateReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_Heartbeat_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Heartbeat is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_Heartbeat_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Heartbeat);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_QuoteAcknowledgement_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_QuoteAcknowledgement is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_QuoteAcknowledgement_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteAcknowledgement);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_AllocationReportAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AllocationReportAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_AllocationReportAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationReportAck);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_ConfirmationRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ConfirmationRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_ConfirmationRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ConfirmationRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_OrderMassActionReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderMassActionReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_OrderMassActionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassActionReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_CollateralInquiry_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CollateralInquiry is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_CollateralInquiry_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralInquiry);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_SecurityTypeRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityTypeRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_SecurityTypeRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityTypeRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_NewOrderList_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_NewOrderList is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_NewOrderList_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NewOrderList);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_ExecutionAcknowledgement_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ExecutionAcknowledgement is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_ExecutionAcknowledgement_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ExecutionAcknowledgement);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_TradingSessionListRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradingSessionListRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_TradingSessionListRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionListRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_SecurityTypes_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityTypes is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_SecurityTypes_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityTypes);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_MarketDefinition_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MarketDefinition is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_MarketDefinition_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDefinition);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_SequenceReset_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SequenceReset is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_SequenceReset_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SequenceReset);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_CollateralResponse_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CollateralResponse is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_CollateralResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralResponse);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_MassQuoteAcknowledgement_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MassQuoteAcknowledgement is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_MassQuoteAcknowledgement_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MassQuoteAcknowledgement);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_QuoteResponse_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_QuoteResponse is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_QuoteResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteResponse);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_QuoteStatusRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_QuoteStatusRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_QuoteStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteStatusRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_QuoteCancel_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_QuoteCancel is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_QuoteCancel_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteCancel);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_ContraryIntentionReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ContraryIntentionReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_ContraryIntentionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ContraryIntentionReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_CrossOrderCancelRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CrossOrderCancelRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_CrossOrderCancelRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CrossOrderCancelRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_NewOrderSingle_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_NewOrderSingle is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_NewOrderSingle_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NewOrderSingle);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_DerivativeSecurityListRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_DerivativeSecurityListRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_DerivativeSecurityListRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityListRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_CollateralRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CollateralRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_CollateralRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_UserNotification_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_UserNotification is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_UserNotification_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_UserNotification);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_UserResponse_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_UserResponse is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_UserResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_UserResponse);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_DontKnowTrade_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_DontKnowTrade is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_DontKnowTrade_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_DontKnowTrade);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_TradeCaptureReportAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradeCaptureReportAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_TradeCaptureReportAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportAck);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_ApplicationMessageRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ApplicationMessageRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_ApplicationMessageRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_MultilegOrderCancelReplace_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MultilegOrderCancelReplace is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_MultilegOrderCancelReplace_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MultilegOrderCancelReplace);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_OrderCancelReject_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderCancelReject is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_OrderCancelReject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderCancelReject);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_ExecutionReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ExecutionReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_ExecutionReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ExecutionReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_QuoteStatusReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_QuoteStatusReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_QuoteStatusReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteStatusReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_ResendRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ResendRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_ResendRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ResendRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_Quote_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Quote is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_Quote_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Quote);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_SettlementInstructionRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SettlementInstructionRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_SettlementInstructionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SettlementInstructionRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_SecurityListUpdateReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityListUpdateReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_SecurityListUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityListUpdateReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_AllocationInstructionAlert_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AllocationInstructionAlert is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_AllocationInstructionAlert_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationInstructionAlert);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_TradeCaptureReportRequestAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradeCaptureReportRequestAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_TradeCaptureReportRequestAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportRequestAck);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_AllocationInstruction_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AllocationInstruction is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_AllocationInstruction_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationInstruction);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_Allocation_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Allocation is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_Allocation_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Allocation);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_RegistrationInstructions_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_RegistrationInstructions is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_RegistrationInstructions_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RegistrationInstructions);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_SecurityDefinition_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityDefinition is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_SecurityDefinition_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinition);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_SecurityDefinitionRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityDefinitionRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_SecurityDefinitionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityDefinitionRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_SecurityStatus_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityStatus is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_SecurityStatus_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityStatus);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_ApplicationMessageReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ApplicationMessageReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_ApplicationMessageReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_DerivativeSecurityList_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_DerivativeSecurityList is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_DerivativeSecurityList_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityList);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_NetworkCounterpartySystemStatusRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_NetworkCounterpartySystemStatusRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_NetworkCounterpartySystemStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_NetworkCounterpartySystemStatusRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_MarketDefinitionRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MarketDefinitionRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_MarketDefinitionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDefinitionRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_Reject_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_Reject is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_Reject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_Reject);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_DerivativeSecurityListUpdateReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_DerivativeSecurityListUpdateReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_DerivativeSecurityListUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_DerivativeSecurityListUpdateReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_QuoteRequestReject_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_QuoteRequestReject is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_QuoteRequestReject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteRequestReject);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_OrderMassStatusRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderMassStatusRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_OrderMassStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassStatusRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_ApplicationMessageRequestAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_ApplicationMessageRequestAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_ApplicationMessageRequestAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_ApplicationMessageRequestAck);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_SecurityStatusRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SecurityStatusRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_SecurityStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SecurityStatusRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_MarketDefinitionUpdateReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MarketDefinitionUpdateReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_MarketDefinitionUpdateReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDefinitionUpdateReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_CrossOrderCancelReplaceRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CrossOrderCancelReplaceRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_CrossOrderCancelReplaceRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CrossOrderCancelReplaceRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_OrderMassCancelReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderMassCancelReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_OrderMassCancelReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassCancelReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_AssignmentReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AssignmentReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_AssignmentReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AssignmentReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_BidResponse_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_BidResponse is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_BidResponse_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_BidResponse);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_RequestForPositions_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_RequestForPositions is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_RequestForPositions_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RequestForPositions);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_SettlementObligationReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SettlementObligationReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_SettlementObligationReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SettlementObligationReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_OrderMassCancelRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderMassCancelRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_OrderMassCancelRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassCancelRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_TradingSessionList_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradingSessionList is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_TradingSessionList_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradingSessionList);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_OrderStatusRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderStatusRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_OrderStatusRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderStatusRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_CollateralAssignment_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CollateralAssignment is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_CollateralAssignment_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralAssignment);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_StreamAssignmentReport_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_StreamAssignmentReport is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_StreamAssignmentReport_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_StreamAssignmentReport);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_OrderMassActionRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderMassActionRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_OrderMassActionRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderMassActionRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_AllocationAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AllocationAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_AllocationAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationAck);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_QuoteRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_QuoteRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_QuoteRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_QuoteRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_CollateralInquiryAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_CollateralInquiryAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_CollateralInquiryAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_CollateralInquiryAck);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_MarketDataSnapshotFullRefresh_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MarketDataSnapshotFullRefresh is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_MarketDataSnapshotFullRefresh_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataSnapshotFullRefresh);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_SettlementInstructions_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_SettlementInstructions is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_SettlementInstructions_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_SettlementInstructions);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_OrderCancelReplaceRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderCancelReplaceRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_OrderCancelReplaceRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderCancelReplaceRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_TradeCaptureReportRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_TradeCaptureReportRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_TradeCaptureReportRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_TradeCaptureReportRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_RFQRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_RFQRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_RFQRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_RFQRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_OrderCancelRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_OrderCancelRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_OrderCancelRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_OrderCancelRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_MultilegOrderCancelReplaceRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MultilegOrderCancelReplaceRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_MultilegOrderCancelReplaceRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MultilegOrderCancelReplaceRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_AllocationInstructionAck_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_AllocationInstructionAck is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_AllocationInstructionAck_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_AllocationInstructionAck);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_MarketDataRequest_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MarketDataRequest is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_MarketDataRequest_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataRequest);
  return pyobj;
}


SWIGINTERN int Swig_var_MsgType_MarketDataRequestReject_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgType_MarketDataRequestReject is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgType_MarketDataRequestReject_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MsgType_MarketDataRequestReject);
  return pyobj;
}


SWIGINTERN int Swig_var_MultiLegReportingType_SINGLE_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegReportingType_SINGLE_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiLegReportingType_SINGLE_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_SINGLE_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MultiLegReportingType_MULTI_LEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegReportingType_MULTI_LEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiLegReportingType_MULTI_LEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_MULTI_LEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_EXCHANGE_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_EXCHANGE_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_EXCHANGE_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_EXCHANGE_SYMBOL);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_RIC_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_RIC_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_RIC_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_RIC_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_ISO_CURRENCY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_ISO_CURRENCY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_ISO_CURRENCY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_ISO_CURRENCY_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_ISIN_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_ISIN_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_ISIN_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_ISIN_NUMBER);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_SEDOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_SEDOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_SEDOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_SEDOL);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_ISO_COUNTRY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_ISO_COUNTRY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_ISO_COUNTRY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_ISO_COUNTRY_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_CONSOLIDATED_TAPE_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_CONSOLIDATED_TAPE_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_CONSOLIDATED_TAPE_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_CONSOLIDATED_TAPE_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_QUIK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_QUIK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_QUIK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_QUIK);
  return pyobj;
}


SWIGINTERN int Swig_var_IDSource_CUSIP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IDSource_CUSIP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IDSource_CUSIP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IDSource_CUSIP);
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_CALCULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_CALCULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_CALCULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_CALCULATED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_PENDING_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PENDING_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_PENDING_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_PENDING_CANCEL_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PENDING_CANCEL_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_PENDING_CANCEL_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_CANCEL_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_PENDING_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PENDING_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_PENDING_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_STOPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_STOPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_STOPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_STOPPED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_FILLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_FILLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_FILLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_FILLED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_PENDING_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PENDING_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_PENDING_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PENDING_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_CANCELED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_CANCELED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_CANCELED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_CANCELED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_ACCEPTED_FOR_BIDDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_ACCEPTED_FOR_BIDDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_ACCEPTED_FOR_BIDDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_ACCEPTED_FOR_BIDDING));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_SUSPENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_SUSPENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_SUSPENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_SUSPENDED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_PARTIALLY_FILLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_PARTIALLY_FILLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_PARTIALLY_FILLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_PARTIALLY_FILLED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_REPLACED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_REPLACED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_REPLACED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_REPLACED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdStatus_DONE_FOR_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdStatus_DONE_FOR_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdStatus_DONE_FOR_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdStatus_DONE_FOR_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_CustomerOrFirm_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustomerOrFirm_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustomerOrFirm_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustomerOrFirm_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_CustomerOrFirm_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustomerOrFirm_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustomerOrFirm_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustomerOrFirm_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_AdjustmentType_DELTA_MINUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_DELTA_MINUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdjustmentType_DELTA_MINUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_DELTA_MINUS));
  return pyobj;
}


SWIGINTERN int Swig_var_AdjustmentType_DELTA_PLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_DELTA_PLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdjustmentType_DELTA_PLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_DELTA_PLUS));
  return pyobj;
}


SWIGINTERN int Swig_var_AdjustmentType_FINAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_FINAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdjustmentType_FINAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_FINAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION));
  return pyobj;
}


SWIGINTERN int Swig_var_AsOfIndicator_TRUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AsOfIndicator_TRUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AsOfIndicator_TRUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AsOfIndicator_TRUE));
  return pyobj;
}


SWIGINTERN int Swig_var_AsOfIndicator_FALSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AsOfIndicator_FALSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AsOfIndicator_FALSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AsOfIndicator_FALSE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_CFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_CFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_CFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_CFICODE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_CANCEL_FOR_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_CANCEL_FOR_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_CANCEL_FOR_SECURITY_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_CANCEL_FOR_SECURITY_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_PIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_PIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_PIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_PIT));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_EX_PIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_EX_PIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_EX_PIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_EX_PIT));
  return pyobj;
}


SWIGINTERN int Swig_var_VenueType_ELECTRONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VenueType_ELECTRONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VenueType_ELECTRONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::VenueType_ELECTRONIC));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionType_CANCEL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionType_CANCEL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionType_CANCEL_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionType_CANCEL_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionType_RELEASE_ORDERS_FROM_SUSPENSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionType_RELEASE_ORDERS_FROM_SUSPENSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionType_RELEASE_ORDERS_FROM_SUSPENSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionType_RELEASE_ORDERS_FROM_SUSPENSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionType_SUSPEND_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionType_SUSPEND_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionType_SUSPEND_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionType_SUSPEND_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintResult_SUCCESSFUL_COMPLETION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintResult_SUCCESSFUL_COMPLETION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintResult_SUCCESSFUL_COMPLETION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_SUCCESSFUL_COMPLETION));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintResult_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintResult_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintResult_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintResult_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIShares_MEDIUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIShares_MEDIUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIShares_MEDIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIShares_MEDIUM);
  return pyobj;
}


SWIGINTERN int Swig_var_IOIShares_LARGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIShares_LARGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIShares_LARGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIShares_LARGE);
  return pyobj;
}


SWIGINTERN int Swig_var_IOIShares_SMALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIShares_SMALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIShares_SMALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIShares_SMALL);
  return pyobj;
}


SWIGINTERN int Swig_var_PegOffsetType_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegOffsetType_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_PegOffsetType_PRICE_TIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_PRICE_TIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegOffsetType_PRICE_TIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_PRICE_TIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PegOffsetType_TICKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_TICKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegOffsetType_TICKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_TICKS));
  return pyobj;
}


SWIGINTERN int Swig_var_PegOffsetType_BASIS_POINTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegOffsetType_BASIS_POINTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegOffsetType_BASIS_POINTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegOffsetType_BASIS_POINTS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING));
  return pyobj;
}


SWIGINTERN int Swig_var_ResponseTransportType_INBAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResponseTransportType_INBAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ResponseTransportType_INBAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ResponseTransportType_INBAND));
  return pyobj;
}


SWIGINTERN int Swig_var_ResponseTransportType_OUT_OF_BAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResponseTransportType_OUT_OF_BAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ResponseTransportType_OUT_OF_BAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ResponseTransportType_OUT_OF_BAND));
  return pyobj;
}


SWIGINTERN int Swig_var_ResponseTransportType_INBAND_TRANSPORT_THE_REQUEST_WAS_SENT_OVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResponseTransportType_INBAND_TRANSPORT_THE_REQUEST_WAS_SENT_OVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ResponseTransportType_INBAND_TRANSPORT_THE_REQUEST_WAS_SENT_OVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ResponseTransportType_INBAND_TRANSPORT_THE_REQUEST_WAS_SENT_OVER));
  return pyobj;
}


SWIGINTERN int Swig_var_ResponseTransportType_OUT_OF_BAND_PRE_ARRANGED_OUT_OF_BAND_DELIVERY_MECHANISM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResponseTransportType_OUT_OF_BAND_PRE_ARRANGED_OUT_OF_BAND_DELIVERY_MECHANISM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ResponseTransportType_OUT_OF_BAND_PRE_ARRANGED_OUT_OF_BAND_DELIVERY_MECHANISM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ResponseTransportType_OUT_OF_BAND_PRE_ARRANGED_OUT_OF_BAND_DELIVERY_MECHANISM));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesStatusRejReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesStatusRejReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesStatusRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesStatusRejReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_EXECUTION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_EXECUTION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_EXECUTION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_EXECUTION_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_TIME_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_TIME_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_TIME_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIME_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_SUBMISSION_TO_CLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_SUBMISSION_TO_CLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_SUBMISSION_TO_CLEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_SUBMISSION_TO_CLEARING));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_DESK_RECEIPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_DESK_RECEIPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_DESK_RECEIPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_DESK_RECEIPT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_BROKER_RECEIPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_BROKER_RECEIPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_BROKER_RECEIPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_BROKER_RECEIPT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_BROKER_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_BROKER_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_BROKER_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_BROKER_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRegTimestampType_TIME_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRegTimestampType_TIME_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRegTimestampType_TIME_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRegTimestampType_TIME_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX50SP1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX50SP1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX50SP1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX50SP1);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX27_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX27 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX27_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX27);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX50SP2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX50SP2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX50SP2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX50SP2);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX50_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX50 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX50_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX50);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX40_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX40 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX40_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX40);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX41_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX41 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX41_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX41);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX30_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX30 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX30_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX30);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX42_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX42 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX42_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX42);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX43_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX43 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX43_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX43);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplVerID_FIX44_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplVerID_FIX44 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplVerID_FIX44_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ApplVerID_FIX44);
  return pyobj;
}


SWIGINTERN int Swig_var_HandlInst_MANUAL_ORDER_BEST_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HandlInst_MANUAL_ORDER_BEST_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HandlInst_MANUAL_ORDER_BEST_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HandlInst_MANUAL_ORDER_BEST_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION));
  return pyobj;
}


SWIGINTERN int Swig_var_HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK));
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_POST_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_POST_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_POST_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_POST_TRADING);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_INTRADAY_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_INTRADAY_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_INTRADAY_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_INTRADAY_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_PRE_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_PRE_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_PRE_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_PRE_TRADING);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_QUIESCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_QUIESCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_QUIESCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_QUIESCENT);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_3);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_OPENING_OR_OPENING_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_OPENING_OR_OPENING_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_OPENING_OR_OPENING_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_OPENING_OR_OPENING_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SWAP_VALUE_FACTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SWAP_VALUE_FACTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SWAP_VALUE_FACTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SWAP_VALUE_FACTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_COMPOSITE_UNDERLYING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_COMPOSITE_UNDERLYING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_COMPOSITE_UNDERLYING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_COMPOSITE_UNDERLYING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SESSION_HIGH_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SESSION_HIGH_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SESSION_HIGH_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SESSION_HIGH_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_OPEN_INTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_OPEN_INTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_OPEN_INTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OPEN_INTEREST));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CLOSING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_PRIOR_SETTLE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_PRIOR_SETTLE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_PRIOR_SETTLE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_PRIOR_SETTLE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_TRADING_SESSION_VWAP_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADING_SESSION_VWAP_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_TRADING_SESSION_VWAP_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADING_SESSION_VWAP_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_TRADING_SESSION_LOW_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADING_SESSION_LOW_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_TRADING_SESSION_LOW_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADING_SESSION_LOW_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SETTLE_HIGH_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SETTLE_HIGH_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SETTLE_HIGH_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SETTLE_HIGH_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_IMBALANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_FIXING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_FIXING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_FIXING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_FIXING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_CASH_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_CASH_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_CASH_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CASH_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_OPENING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_OPENING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_OPENING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OPENING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SIMULATED_SELL_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SIMULATED_SELL_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SIMULATED_SELL_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SIMULATED_SELL_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_EMPTY_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_EMPTY_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_EMPTY_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_EMPTY_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_AUCTION_CLEARING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_AUCTION_CLEARING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_AUCTION_CLEARING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_AUCTION_CLEARING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_RECOVERY_RATE_FOR_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_RECOVERY_RATE_FOR_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_RECOVERY_RATE_FOR_SHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_RECOVERY_RATE_FOR_SHORT));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SIMULATED_BUY_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SIMULATED_BUY_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SIMULATED_BUY_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SIMULATED_BUY_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_EARLY_PRICES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_EARLY_PRICES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_EARLY_PRICES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_EARLY_PRICES));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_TRADING_SESSION_HIGH_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADING_SESSION_HIGH_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_TRADING_SESSION_HIGH_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADING_SESSION_HIGH_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_INDEX_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_INDEX_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_INDEX_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_INDEX_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_RECOVERY_RATE_FOR_LONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_RECOVERY_RATE_FOR_LONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_RECOVERY_RATE_FOR_LONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_RECOVERY_RATE_FOR_LONG));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_MID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_MID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_MID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_MID_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_RECOVERY_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_RECOVERY_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_RECOVERY_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_RECOVERY_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_MARGIN_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_MARGIN_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_MARGIN_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_MARGIN_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SETTLE_LOW_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SETTLE_LOW_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SETTLE_LOW_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SETTLE_LOW_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SESSION_LOW_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SESSION_LOW_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SESSION_LOW_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SESSION_LOW_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_TRADE_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_TRADE_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_TRADE_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_TRADE_VOLUME));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_SETTLEMENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_SETTLEMENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_SETTLEMENT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_SETTLEMENT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDEntryType_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDEntryType_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDEntryType_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDEntryType_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_PegMoveType_FLOATING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegMoveType_FLOATING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegMoveType_FLOATING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegMoveType_FLOATING));
  return pyobj;
}


SWIGINTERN int Swig_var_PegMoveType_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegMoveType_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegMoveType_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegMoveType_FIXED));
  return pyobj;
}


SWIGINTERN int Swig_var_AvgPxIndicator_LAST_TRADE_IN_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AvgPxIndicator_LAST_TRADE_IN_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AvgPxIndicator_LAST_TRADE_IN_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_LAST_TRADE_IN_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID));
  return pyobj;
}


SWIGINTERN int Swig_var_AvgPxIndicator_NO_AVERAGE_PRICING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AvgPxIndicator_NO_AVERAGE_PRICING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AvgPxIndicator_NO_AVERAGE_PRICING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_NO_AVERAGE_PRICING));
  return pyobj;
}


SWIGINTERN int Swig_var_AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID));
  return pyobj;
}


SWIGINTERN int Swig_var_AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID));
  return pyobj;
}


SWIGINTERN int Swig_var_CancellationRights_NO_WAIVER_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_WAIVER_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CancellationRights_NO_WAIVER_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_WAIVER_AGREEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CancellationRights_NO_M_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_M is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CancellationRights_NO_M_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_M));
  return pyobj;
}


SWIGINTERN int Swig_var_CancellationRights_NO_N_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_N is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CancellationRights_NO_N_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_N));
  return pyobj;
}


SWIGINTERN int Swig_var_CancellationRights_NO_INSTITUTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_INSTITUTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CancellationRights_NO_INSTITUTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_INSTITUTIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CancellationRights_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CancellationRights_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_CancellationRights_NO_O_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_O is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CancellationRights_NO_O_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_O));
  return pyobj;
}


SWIGINTERN int Swig_var_CancellationRights_NO_EXECUTION_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CancellationRights_NO_EXECUTION_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CancellationRights_NO_EXECUTION_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CancellationRights_NO_EXECUTION_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_CREATION_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_CREATION_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_CREATION_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATION_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_BID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_BID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_BID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_BID_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_SINGLE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_SINGLE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_SINGLE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_SINGLE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecPriceType_OFFER_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecPriceType_OFFER_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecPriceType_OFFER_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecPriceType_OFFER_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocSettlInstType_PHONE_FOR_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_PHONE_FOR_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocSettlInstType_PHONE_FOR_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_PHONE_FOR_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocSettlInstType_SSI_DB_IDS_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_SSI_DB_IDS_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocSettlInstType_SSI_DB_IDS_PROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_SSI_DB_IDS_PROVIDED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocSettlInstType_FULL_DETAILS_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_FULL_DETAILS_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocSettlInstType_FULL_DETAILS_PROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_FULL_DETAILS_PROVIDED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_StatsType_AVERAGE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatsType_AVERAGE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatsType_AVERAGE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatsType_AVERAGE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_StatsType_HIGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatsType_HIGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatsType_HIGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatsType_HIGH));
  return pyobj;
}


SWIGINTERN int Swig_var_StatsType_EXCHANGE_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatsType_EXCHANGE_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatsType_EXCHANGE_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatsType_EXCHANGE_LAST));
  return pyobj;
}


SWIGINTERN int Swig_var_StatsType_TURNOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatsType_TURNOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatsType_TURNOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatsType_TURNOVER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesMode_SIMULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMode_SIMULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesMode_SIMULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMode_SIMULATED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesMode_PRODUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMode_PRODUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesMode_PRODUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMode_PRODUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesMode_TESTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMode_TESTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesMode_TESTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMode_TESTING));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstSource_INSTITUTIONS_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstSource_INSTITUTIONS_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstSource_INSTITUTIONS_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_INSTITUTIONS_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstSource_BROKERS_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstSource_BROKERS_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstSource_BROKERS_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_BROKERS_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstSource_INVESTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstSource_INVESTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstSource_INVESTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstSource_INVESTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpType_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpType_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpType_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpType_FINAL_WILL_BE_EXERCISED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_FINAL_WILL_BE_EXERCISED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpType_FINAL_WILL_BE_EXERCISED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpType_FINAL_WILL_BE_EXERCISED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpType_NON_AUTO_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_NON_AUTO_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpType_NON_AUTO_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpType_NON_AUTO_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpType_CONTRARY_INTENTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_CONTRARY_INTENTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpType_CONTRARY_INTENTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpType_CONTRARY_INTENTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpType_AUTO_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpType_AUTO_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpType_AUTO_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpType_AUTO_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstTransType_RESTATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstTransType_RESTATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstTransType_RESTATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_RESTATE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_INVALID_DESTINATION_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALID_DESTINATION_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_INVALID_DESTINATION_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_DESTINATION_REQUESTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_UNAUTHORIZED_FOR_TRADE_CAPTURE_REPORT_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_UNAUTHORIZED_FOR_TRADE_CAPTURE_REPORT_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_UNAUTHORIZED_FOR_TRADE_CAPTURE_REPORT_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_UNAUTHORIZED_FOR_TRADE_CAPTURE_REPORT_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_SUCCESSFUL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_SUCCESSFUL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_SUCCESSFUL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_SUCCESSFUL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_INVALID_PARTIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALID_PARTIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_INVALID_PARTIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_PARTIES));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_NOT_AUTHORIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_NOT_AUTHORIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_NOT_AUTHORIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_NOT_AUTHORIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TestMessageIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TestMessageIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TestMessageIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TestMessageIndicator_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_TestMessageIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TestMessageIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TestMessageIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TestMessageIndicator_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocCancReplaceReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocCancReplaceReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocCancReplaceReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_DUPLICATE_CLORDID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_DUPLICATE_CLORDID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_DUPLICATE_CLORDID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_DUPLICATE_CLORDID));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_DUPLICATE_CLORDID_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_DUPLICATE_CLORDID_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_DUPLICATE_CLORDID_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_DUPLICATE_CLORDID_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_UNKNOWN_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_UNKNOWN_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_UNKNOWN_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_UNKNOWN_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_TOO_LATE_TO_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_TOO_LATE_TO_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_TOO_LATE_TO_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_TOO_LATE_TO_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_INVALID_PRICE_INCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_INVALID_PRICE_INCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_INVALID_PRICE_INCREMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_INVALID_PRICE_INCREMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_ORIGORDMODTIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_ORIGORDMODTIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_ORIGORDMODTIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_ORIGORDMODTIME));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_BROKER));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_BROKER_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_BROKER_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_BROKER_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_BROKER_OPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_RespondentType_SPECIFIED_MARKET_PARTICIPANTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RespondentType_SPECIFIED_MARKET_PARTICIPANTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RespondentType_SPECIFIED_MARKET_PARTICIPANTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RespondentType_SPECIFIED_MARKET_PARTICIPANTS));
  return pyobj;
}


SWIGINTERN int Swig_var_RespondentType_ALL_MARKET_MAKERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RespondentType_ALL_MARKET_MAKERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RespondentType_ALL_MARKET_MAKERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RespondentType_ALL_MARKET_MAKERS));
  return pyobj;
}


SWIGINTERN int Swig_var_RespondentType_ALL_MARKET_PARTICIPANTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RespondentType_ALL_MARKET_PARTICIPANTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RespondentType_ALL_MARKET_PARTICIPANTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RespondentType_ALL_MARKET_PARTICIPANTS));
  return pyobj;
}


SWIGINTERN int Swig_var_RespondentType_PRIMARY_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RespondentType_PRIMARY_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RespondentType_PRIMARY_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RespondentType_PRIMARY_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_NO_MATCHING_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_NO_MATCHING_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_NO_MATCHING_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_NO_MATCHING_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_PRICE_EXCEEDS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_PRICE_EXCEEDS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_PRICE_EXCEEDS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_PRICE_EXCEEDS_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_QUANTITY_EXCEEDS_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_QUANTITY_EXCEEDS_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_QUANTITY_EXCEEDS_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_QUANTITY_EXCEEDS_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_WRONG_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_WRONG_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_WRONG_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_WRONG_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_DKReason_CALCULATION_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DKReason_CALCULATION_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DKReason_CALCULATION_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DKReason_CALCULATION_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionEffect_DEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_DEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionEffect_DEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_DEFAULT));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionEffect_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionEffect_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionEffect_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionEffect_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionEffect_FIFO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_FIFO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionEffect_FIFO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_FIFO));
  return pyobj;
}


SWIGINTERN int Swig_var_PositionEffect_ROLLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PositionEffect_ROLLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PositionEffect_ROLLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PositionEffect_ROLLED));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerAction_ACTIVATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerAction_ACTIVATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerAction_ACTIVATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerAction_ACTIVATE));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerAction_MODIFY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerAction_MODIFY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerAction_MODIFY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerAction_MODIFY));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerAction_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerAction_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerAction_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerAction_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_EXCLUDE_FROM_ALL_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_EXCLUDE_FROM_ALL_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_EXCLUDE_FROM_ALL_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EXCLUDE_FROM_ALL_NETTING));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_AUTOMATIC_POSTING_MODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_AUTOMATIC_POSTING_MODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_AUTOMATIC_POSTING_MODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_AUTOMATIC_POSTING_MODE));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_MULTILATERAL_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_MULTILATERAL_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_MULTILATERAL_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_MULTILATERAL_NETTING));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_AUTOMATIC_GIVE_UP_MODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_AUTOMATIC_GIVE_UP_MODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_AUTOMATIC_GIVE_UP_MODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_AUTOMATIC_GIVE_UP_MODE));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_CUSTOMER_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_CUSTOMER_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_CUSTOMER_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_CUSTOMER_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_EX_CLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_EX_CLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_EX_CLEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_EX_CLEARING));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_BILATERAL_NETTING_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_BILATERAL_NETTING_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_BILATERAL_NETTING_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_BILATERAL_NETTING_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_PROCESS_NORMALLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_PROCESS_NORMALLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_PROCESS_NORMALLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_PROCESS_NORMALLY));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_SPECIAL_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_SPECIAL_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_SPECIAL_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_SPECIAL_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_MANUAL_MODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_MANUAL_MODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_MANUAL_MODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_MANUAL_MODE));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_ClearingInstruction_SELF_CLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ClearingInstruction_SELF_CLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ClearingInstruction_SELF_CLEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ClearingInstruction_SELF_CLEARING));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettlFlag_SESSION_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_SESSION_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettlFlag_SESSION_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_SESSION_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettlFlag_EXPECTED_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_EXPECTED_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettlFlag_EXPECTED_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_EXPECTED_ENTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettlFlag_DAILY_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_DAILY_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettlFlag_DAILY_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_DAILY_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionMoveType_FLOATING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionMoveType_FLOATING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionMoveType_FLOATING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionMoveType_FLOATING));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionMoveType_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionMoveType_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionMoveType_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionMoveType_FIXED));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateType_INCREMENTAL_REFRESH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateType_INCREMENTAL_REFRESH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateType_INCREMENTAL_REFRESH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDUpdateType_INCREMENTAL_REFRESH));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateType_FULL_REFRESH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateType_FULL_REFRESH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateType_FULL_REFRESH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDUpdateType_FULL_REFRESH));
  return pyobj;
}


SWIGINTERN int Swig_var_TickDirection_MINUS_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_MINUS_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickDirection_MINUS_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TickDirection_MINUS_TICK));
  return pyobj;
}


SWIGINTERN int Swig_var_TickDirection_ZERO_PLUS_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_ZERO_PLUS_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickDirection_ZERO_PLUS_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TickDirection_ZERO_PLUS_TICK));
  return pyobj;
}


SWIGINTERN int Swig_var_TickDirection_ZERO_MINUS_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_ZERO_MINUS_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickDirection_ZERO_MINUS_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TickDirection_ZERO_MINUS_TICK));
  return pyobj;
}


SWIGINTERN int Swig_var_TickDirection_PLUS_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickDirection_PLUS_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickDirection_PLUS_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TickDirection_PLUS_TICK));
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_MARK_TO_MARKET_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_MARK_TO_MARKET_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_MARK_TO_MARKET_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_MARK_TO_MARKET_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_MATURITY);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_COMPOUND_YIELD_THE_YIELD_OF_CERTAIN_JAPANESE_BONDS_BASED_ON_ITS_PRICE_CERTAIN_JAPANESE_BONDS_HAVE_IRREGULAR_FIRST_OR_LAST_COUPONS_AND_THE_YIELD_IS_CALCULATED_COMPOUND_FOR_THESE_IRREGULAR_PERIODS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_COMPOUND_YIELD_THE_YIELD_OF_CERTAIN_JAPANESE_BONDS_BASED_ON_ITS_PRICE_CERTAIN_JAPANESE_BONDS_HAVE_IRREGULAR_FIRST_OR_LAST_COUPONS_AND_THE_YIELD_IS_CALCULATED_COMPOUND_FOR_THESE_IRREGULAR_PERIODS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_COMPOUND_YIELD_THE_YIELD_OF_CERTAIN_JAPANESE_BONDS_BASED_ON_ITS_PRICE_CERTAIN_JAPANESE_BONDS_HAVE_IRREGULAR_FIRST_OR_LAST_COUPONS_AND_THE_YIELD_IS_CALCULATED_COMPOUND_FOR_THESE_IRREGULAR_PERIODS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_COMPOUND_YIELD_THE_YIELD_OF_CERTAIN_JAPANESE_BONDS_BASED_ON_ITS_PRICE_CERTAIN_JAPANESE_BONDS_HAVE_IRREGULAR_FIRST_OR_LAST_COUPONS_AND_THE_YIELD_IS_CALCULATED_COMPOUND_FOR_THESE_IRREGULAR_PERIODS);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_PREVIOUS_CLOSE_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_PREVIOUS_CLOSE_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_PREVIOUS_CLOSE_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_PREVIOUS_CLOSE_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_AT_ISSUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_AT_ISSUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_AT_ISSUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_AT_ISSUE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_NEXT_REFUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_NEXT_REFUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_NEXT_REFUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_REFUND);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_AFTER_TAX_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_AFTER_TAX_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_AFTER_TAX_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_AFTER_TAX_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_GVNT_EQUIVALENT_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_GVNT_EQUIVALENT_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_GVNT_EQUIVALENT_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_GVNT_EQUIVALENT_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_SAME_AS_AVGLIFE_ABOVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_SAME_AS_AVGLIFE_ABOVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_SAME_AS_AVGLIFE_ABOVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_SAME_AS_AVGLIFE_ABOVE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_CHANGE_SINCE_CLOSE_THE_CHANGE_IN_THE_YIELD_SINCE_THE_PREVIOUS_DAYS_CLOSING_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_CHANGE_SINCE_CLOSE_THE_CHANGE_IN_THE_YIELD_SINCE_THE_PREVIOUS_DAYS_CLOSING_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_CHANGE_SINCE_CLOSE_THE_CHANGE_IN_THE_YIELD_SINCE_THE_PREVIOUS_DAYS_CLOSING_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_CHANGE_SINCE_CLOSE_THE_CHANGE_IN_THE_YIELD_SINCE_THE_PREVIOUS_DAYS_CLOSING_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CURRENT_YIELD_ANNUAL_INTEREST_ON_A_BOND_DIVIDED_BY_THE_MARKET_VALUE_THE_ACTUAL_INCOME_RATE_OF_RETURN_AS_OPPOSED_TO_THE_COUPON_RATE_EXPRESSED_AS_A_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CURRENT_YIELD_ANNUAL_INTEREST_ON_A_BOND_DIVIDED_BY_THE_MARKET_VALUE_THE_ACTUAL_INCOME_RATE_OF_RETURN_AS_OPPOSED_TO_THE_COUPON_RATE_EXPRESSED_AS_A_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CURRENT_YIELD_ANNUAL_INTEREST_ON_A_BOND_DIVIDED_BY_THE_MARKET_VALUE_THE_ACTUAL_INCOME_RATE_OF_RETURN_AS_OPPOSED_TO_THE_COUPON_RATE_EXPRESSED_AS_A_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CURRENT_YIELD_ANNUAL_INTEREST_ON_A_BOND_DIVIDED_BY_THE_MARKET_VALUE_THE_ACTUAL_INCOME_RATE_OF_RETURN_AS_OPPOSED_TO_THE_COUPON_RATE_EXPRESSED_AS_A_PERCENTAGE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSING_YIELD_MOST_RECENT_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_NEXT_CALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_NEXT_CALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_NEXT_CALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_CALL);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_CHANGE_SINCE_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_CHANGE_SINCE_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_CHANGE_SINCE_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_CHANGE_SINCE_CLOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_PROCEEDS_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_PROCEEDS_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_PROCEEDS_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_PROCEEDS_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_TAX_EQUIVALENT_YIELD_THE_AFTER_TAX_YIELD_GROSSED_UP_BY_THE_MAXIMUM_FEDERAL_TAX_RATE_OF_396_FOR_COMPARISON_TO_TAXABLE_YIELDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TAX_EQUIVALENT_YIELD_THE_AFTER_TAX_YIELD_GROSSED_UP_BY_THE_MAXIMUM_FEDERAL_TAX_RATE_OF_396_FOR_COMPARISON_TO_TAXABLE_YIELDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_TAX_EQUIVALENT_YIELD_THE_AFTER_TAX_YIELD_GROSSED_UP_BY_THE_MAXIMUM_FEDERAL_TAX_RATE_OF_396_FOR_COMPARISON_TO_TAXABLE_YIELDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TAX_EQUIVALENT_YIELD_THE_AFTER_TAX_YIELD_GROSSED_UP_BY_THE_MAXIMUM_FEDERAL_TAX_RATE_OF_396_FOR_COMPARISON_TO_TAXABLE_YIELDS);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_INVERSE_FLOATER_BOND_YIELD_INVERSE_FLOATER_SEMI_ANNUAL_BOND_EQUIVALENT_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_INVERSE_FLOATER_BOND_YIELD_INVERSE_FLOATER_SEMI_ANNUAL_BOND_EQUIVALENT_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_INVERSE_FLOATER_BOND_YIELD_INVERSE_FLOATER_SEMI_ANNUAL_BOND_EQUIVALENT_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_INVERSE_FLOATER_BOND_YIELD_INVERSE_FLOATER_SEMI_ANNUAL_BOND_EQUIVALENT_RATE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CURRENT_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CURRENT_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CURRENT_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CURRENT_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_BOOK_YIELD_THE_YIELD_OF_A_SECURITY_CALCULATED_BY_USING_ITS_BOOK_VALUE_INSTEAD_OF_THE_CURRENT_MARKET_PRICE_THIS_TERM_IS_TYPICALLY_USED_IN_THE_US_DOMESTIC_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_BOOK_YIELD_THE_YIELD_OF_A_SECURITY_CALCULATED_BY_USING_ITS_BOOK_VALUE_INSTEAD_OF_THE_CURRENT_MARKET_PRICE_THIS_TERM_IS_TYPICALLY_USED_IN_THE_US_DOMESTIC_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_BOOK_YIELD_THE_YIELD_OF_A_SECURITY_CALCULATED_BY_USING_ITS_BOOK_VALUE_INSTEAD_OF_THE_CURRENT_MARKET_PRICE_THIS_TERM_IS_TYPICALLY_USED_IN_THE_US_DOMESTIC_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_BOOK_YIELD_THE_YIELD_OF_A_SECURITY_CALCULATED_BY_USING_ITS_BOOK_VALUE_INSTEAD_OF_THE_CURRENT_MARKET_PRICE_THIS_TERM_IS_TYPICALLY_USED_IN_THE_US_DOMESTIC_MARKET);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_COMPOUND_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_COMPOUND_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_COMPOUND_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_COMPOUND_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_NEXT_PUT_THE_YIELD_TO_THE_DATE_AT_WHICH_THE_BOND_HOLDER_CAN_NEXT_PUT_THE_BOND_TO_THE_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_NEXT_PUT_THE_YIELD_TO_THE_DATE_AT_WHICH_THE_BOND_HOLDER_CAN_NEXT_PUT_THE_BOND_TO_THE_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_NEXT_PUT_THE_YIELD_TO_THE_DATE_AT_WHICH_THE_BOND_HOLDER_CAN_NEXT_PUT_THE_BOND_TO_THE_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_PUT_THE_YIELD_TO_THE_DATE_AT_WHICH_THE_BOND_HOLDER_CAN_NEXT_PUT_THE_BOND_TO_THE_ISSUER);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_GOVERNMENT_EQUIVALENT_YIELD_ASK_YIELD_BASED_ON_SEMI_ANNUAL_COUPONS_COMPOUNDING_IN_ALL_PERIODS_AND_ACTUAL_ACTUAL_CALENDAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_GOVERNMENT_EQUIVALENT_YIELD_ASK_YIELD_BASED_ON_SEMI_ANNUAL_COUPONS_COMPOUNDING_IN_ALL_PERIODS_AND_ACTUAL_ACTUAL_CALENDAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_GOVERNMENT_EQUIVALENT_YIELD_ASK_YIELD_BASED_ON_SEMI_ANNUAL_COUPONS_COMPOUNDING_IN_ALL_PERIODS_AND_ACTUAL_ACTUAL_CALENDAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_GOVERNMENT_EQUIVALENT_YIELD_ASK_YIELD_BASED_ON_SEMI_ANNUAL_COUPONS_COMPOUNDING_IN_ALL_PERIODS_AND_ACTUAL_ACTUAL_CALENDAR);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_TENDER_DATE_THE_YIELD_ON_A_MUNICIPAL_BOND_TO_ITS_MANDATORY_TENDER_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_TENDER_DATE_THE_YIELD_ON_A_MUNICIPAL_BOND_TO_ITS_MANDATORY_TENDER_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_TENDER_DATE_THE_YIELD_ON_A_MUNICIPAL_BOND_TO_ITS_MANDATORY_TENDER_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_TENDER_DATE_THE_YIELD_ON_A_MUNICIPAL_BOND_TO_ITS_MANDATORY_TENDER_DATE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_AVG_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_AVG_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_AVG_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_AVG_MATURITY);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_TENDER_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_TENDER_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_TENDER_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_TENDER_DATE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_MONTHS_END_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_MONTHS_END is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_MONTHS_END_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_MONTHS_END);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_YEARS_END_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_YEARS_END is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_YEARS_END_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_YEARS_END);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_ANNUAL_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_ANNUAL_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_ANNUAL_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_ANNUAL_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_WORST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_WORST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_WORST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_WORST);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_NEXT_PUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_NEXT_PUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_NEXT_PUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_PUT);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_BOOK_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_BOOK_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_BOOK_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_BOOK_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_TRUE_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TRUE_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_TRUE_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TRUE_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_TRUE_YIELD_THE_YIELD_CALCULATED_WITH_COUPON_DATES_MOVED_FROM_A_WEEKEND_OR_HOLIDAY_TO_THE_NEXT_VALID_SETTLEMENT_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TRUE_YIELD_THE_YIELD_CALCULATED_WITH_COUPON_DATES_MOVED_FROM_A_WEEKEND_OR_HOLIDAY_TO_THE_NEXT_VALID_SETTLEMENT_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_TRUE_YIELD_THE_YIELD_CALCULATED_WITH_COUPON_DATES_MOVED_FROM_A_WEEKEND_OR_HOLIDAY_TO_THE_NEXT_VALID_SETTLEMENT_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TRUE_YIELD_THE_YIELD_CALCULATED_WITH_COUPON_DATES_MOVED_FROM_A_WEEKEND_OR_HOLIDAY_TO_THE_NEXT_VALID_SETTLEMENT_DATE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_SEMI_ANNUAL_YIELD_THE_YIELD_OF_A_BOND_WHOSE_COUPON_PAYMENTS_ARE_REINVESTED_SEMI_ANNUALLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_SEMI_ANNUAL_YIELD_THE_YIELD_OF_A_BOND_WHOSE_COUPON_PAYMENTS_ARE_REINVESTED_SEMI_ANNUALLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_SEMI_ANNUAL_YIELD_THE_YIELD_OF_A_BOND_WHOSE_COUPON_PAYMENTS_ARE_REINVESTED_SEMI_ANNUALLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_SEMI_ANNUAL_YIELD_THE_YIELD_OF_A_BOND_WHOSE_COUPON_PAYMENTS_ARE_REINVESTED_SEMI_ANNUALLY);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_TAX_EQUIVALENT_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TAX_EQUIVALENT_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_TAX_EQUIVALENT_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TAX_EQUIVALENT_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_PREVIOUS_CLOSE_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_1_DAY_AGO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_PREVIOUS_CLOSE_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_1_DAY_AGO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_PREVIOUS_CLOSE_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_1_DAY_AGO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_PREVIOUS_CLOSE_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_1_DAY_AGO);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_VALUE_OF_1_32_THE_AMOUNT_THAT_THE_YIELD_WILL_CHANGE_FOR_A_1_32ND_CHANGE_IN_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_VALUE_OF_1_32_THE_AMOUNT_THAT_THE_YIELD_WILL_CHANGE_FOR_A_1_32ND_CHANGE_IN_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_VALUE_OF_1_32_THE_AMOUNT_THAT_THE_YIELD_WILL_CHANGE_FOR_A_1_32ND_CHANGE_IN_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_VALUE_OF_1_32_THE_AMOUNT_THAT_THE_YIELD_WILL_CHANGE_FOR_A_1_32ND_CHANGE_IN_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_TRUE_GROSS_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TRUE_GROSS_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_TRUE_GROSS_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TRUE_GROSS_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_LONGEST_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_LONGEST_AVERAGE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_INVERSE_FLOATER_BOND_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_INVERSE_FLOATER_BOND_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_INVERSE_FLOATER_BOND_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_INVERSE_FLOATER_BOND_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSING_YIELD_MOST_RECENT_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_AVERAGE_LIFE_THE_YIELD_ASSUMING_THAT_ALL_SINKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_AVERAGE_LIFE_THE_YIELD_ASSUMING_THAT_ALL_SINKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_AVERAGE_LIFE_THE_YIELD_ASSUMING_THAT_ALL_SINKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_AVERAGE_LIFE_THE_YIELD_ASSUMING_THAT_ALL_SINKS);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_QUARTERS_END_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_QUARTERS_END is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_QUARTERS_END_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_QUARTERS_END);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_SHORTEST_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_SHORTEST_AVERAGE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_OPEN_AVERAGE_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_OPEN_AVERAGE_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_OPEN_AVERAGE_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_OPEN_AVERAGE_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_TRUE_GROSS_YIELD_YIELD_CALCULATED_USING_THE_PRICE_INCLUDING_ACCRUED_INTEREST_WHERE_COUPON_DATES_ARE_MOVED_FROM_HOLIDAYS_AND_WEEKENDS_TO_THE_NEXT_TRADING_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_TRUE_GROSS_YIELD_YIELD_CALCULATED_USING_THE_PRICE_INCLUDING_ACCRUED_INTEREST_WHERE_COUPON_DATES_ARE_MOVED_FROM_HOLIDAYS_AND_WEEKENDS_TO_THE_NEXT_TRADING_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_TRUE_GROSS_YIELD_YIELD_CALCULATED_USING_THE_PRICE_INCLUDING_ACCRUED_INTEREST_WHERE_COUPON_DATES_ARE_MOVED_FROM_HOLIDAYS_AND_WEEKENDS_TO_THE_NEXT_TRADING_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_TRUE_GROSS_YIELD_YIELD_CALCULATED_USING_THE_PRICE_INCLUDING_ACCRUED_INTEREST_WHERE_COUPON_DATES_ARE_MOVED_FROM_HOLIDAYS_AND_WEEKENDS_TO_THE_NEXT_TRADING_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_PROCEEDS_YIELD_THE_CD_EQUIVALENT_YIELD_WHEN_THE_REMAINING_TIME_TO_MATURITY_IS_LESS_THAN_TWO_YEARS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_PROCEEDS_YIELD_THE_CD_EQUIVALENT_YIELD_WHEN_THE_REMAINING_TIME_TO_MATURITY_IS_LESS_THAN_TWO_YEARS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_PROCEEDS_YIELD_THE_CD_EQUIVALENT_YIELD_WHEN_THE_REMAINING_TIME_TO_MATURITY_IS_LESS_THAN_TWO_YEARS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_PROCEEDS_YIELD_THE_CD_EQUIVALENT_YIELD_WHEN_THE_REMAINING_TIME_TO_MATURITY_IS_LESS_THAN_TWO_YEARS);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_WITH_INFLATION_ASSUMPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_WITH_INFLATION_ASSUMPTION);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_THE_YIELD_ASSUMING_ONLY_MANDATORY_SINKS_ARE_TAKEN_THIS_RESULTS_IN_A_LOWER_PAYDOWN_OF_DEBT_THE_YIELD_IS_THEN_CALCULATED_TO_THE_FINAL_PAYMENT_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_THE_YIELD_ASSUMING_ONLY_MANDATORY_SINKS_ARE_TAKEN_THIS_RESULTS_IN_A_LOWER_PAYDOWN_OF_DEBT_THE_YIELD_IS_THEN_CALCULATED_TO_THE_FINAL_PAYMENT_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_THE_YIELD_ASSUMING_ONLY_MANDATORY_SINKS_ARE_TAKEN_THIS_RESULTS_IN_A_LOWER_PAYDOWN_OF_DEBT_THE_YIELD_IS_THEN_CALCULATED_TO_THE_FINAL_PAYMENT_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_THE_YIELD_ASSUMING_ONLY_MANDATORY_SINKS_ARE_TAKEN_THIS_RESULTS_IN_A_LOWER_PAYDOWN_OF_DEBT_THE_YIELD_IS_THEN_CALCULATED_TO_THE_FINAL_PAYMENT_DATE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_MARK_TO_MARKET_YIELD_AN_ADJUSTMENT_IN_THE_VALUATION_OF_A_SECURITIES_PORTFOLIO_TO_REFLECT_THE_CURRENT_MARKET_VALUES_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_MARK_TO_MARKET_YIELD_AN_ADJUSTMENT_IN_THE_VALUATION_OF_A_SECURITIES_PORTFOLIO_TO_REFLECT_THE_CURRENT_MARKET_VALUES_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_MARK_TO_MARKET_YIELD_AN_ADJUSTMENT_IN_THE_VALUATION_OF_A_SECURITIES_PORTFOLIO_TO_REFLECT_THE_CURRENT_MARKET_VALUES_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_MARK_TO_MARKET_YIELD_AN_ADJUSTMENT_IN_THE_VALUATION_OF_A_SECURITIES_PORTFOLIO_TO_REFLECT_THE_CURRENT_MARKET_VALUES_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_AVERAGE_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_AVERAGE_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_AVERAGE_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_AVERAGE_MATURITY);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_WORST_CONVENTION_THE_LOWEST_YIELD_TO_ALL_POSSIBLE_REDEMPTION_DATE_SCENARIOS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_WORST_CONVENTION_THE_LOWEST_YIELD_TO_ALL_POSSIBLE_REDEMPTION_DATE_SCENARIOS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_WORST_CONVENTION_THE_LOWEST_YIELD_TO_ALL_POSSIBLE_REDEMPTION_DATE_SCENARIOS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_WORST_CONVENTION_THE_LOWEST_YIELD_TO_ALL_POSSIBLE_REDEMPTION_DATE_SCENARIOS);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_NEXT_CALL_THE_YIELD_OF_A_BOND_TO_THE_NEXT_POSSIBLE_CALL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_NEXT_CALL_THE_YIELD_OF_A_BOND_TO_THE_NEXT_POSSIBLE_CALL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_NEXT_CALL_THE_YIELD_OF_A_BOND_TO_THE_NEXT_POSSIBLE_CALL_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_NEXT_CALL_THE_YIELD_OF_A_BOND_TO_THE_NEXT_POSSIBLE_CALL_DATE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_SIMPLE_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_SIMPLE_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_SIMPLE_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_SIMPLE_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_ANNUAL_YIELD_THE_ANNUAL_INTEREST_OR_DIVIDEND_INCOME_AN_INVESTMENT_EARNS_EXPRESSED_AS_A_PERCENTAGE_OF_THE_INVESTMENTS_TOTAL_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_ANNUAL_YIELD_THE_ANNUAL_INTEREST_OR_DIVIDEND_INCOME_AN_INVESTMENT_EARNS_EXPRESSED_AS_A_PERCENTAGE_OF_THE_INVESTMENTS_TOTAL_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_ANNUAL_YIELD_THE_ANNUAL_INTEREST_OR_DIVIDEND_INCOME_AN_INVESTMENT_EARNS_EXPRESSED_AS_A_PERCENTAGE_OF_THE_INVESTMENTS_TOTAL_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_ANNUAL_YIELD_THE_ANNUAL_INTEREST_OR_DIVIDEND_INCOME_AN_INVESTMENT_EARNS_EXPRESSED_AS_A_PERCENTAGE_OF_THE_INVESTMENTS_TOTAL_VALUE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_SEMI_ANNUAL_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_SEMI_ANNUAL_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_SEMI_ANNUAL_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_SEMI_ANNUAL_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_MOST_RECENT_CLOSING_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_MOST_RECENT_CLOSING_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_MOST_RECENT_CLOSING_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_MOST_RECENT_CLOSING_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_GOVERNMENT_EQUIVALENT_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_GOVERNMENT_EQUIVALENT_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_GOVERNMENT_EQUIVALENT_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_GOVERNMENT_EQUIVALENT_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_CLOSING_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_CLOSING_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_CLOSING_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_CLOSING_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_BASED_ON_PRICE_THE_RETURN_AN_INVESTOR_WOULD_REQUIRE_ON_A_NORMAL_BOND_THAT_WOULD_MAKE_THE_REAL_RETURN_EQUAL_TO_THAT_OF_THE_INFLATION_INDEXED_BOND_ASSUMING_A_CONSTANT_INFLATION_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_WITH_INFLATION_ASSUMPTION_BASED_ON_PRICE_THE_RETURN_AN_INVESTOR_WOULD_REQUIRE_ON_A_NORMAL_BOND_THAT_WOULD_MAKE_THE_REAL_RETURN_EQUAL_TO_THAT_OF_THE_INFLATION_INDEXED_BOND_ASSUMING_A_CONSTANT_INFLATION_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_BASED_ON_PRICE_THE_RETURN_AN_INVESTOR_WOULD_REQUIRE_ON_A_NORMAL_BOND_THAT_WOULD_MAKE_THE_REAL_RETURN_EQUAL_TO_THAT_OF_THE_INFLATION_INDEXED_BOND_ASSUMING_A_CONSTANT_INFLATION_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_WITH_INFLATION_ASSUMPTION_BASED_ON_PRICE_THE_RETURN_AN_INVESTOR_WOULD_REQUIRE_ON_A_NORMAL_BOND_THAT_WOULD_MAKE_THE_REAL_RETURN_EQUAL_TO_THAT_OF_THE_INFLATION_INDEXED_BOND_ASSUMING_A_CONSTANT_INFLATION_RATE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_VALUE_OF_1_32_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_VALUE_OF_1_32 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_VALUE_OF_1_32_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_VALUE_OF_1_32);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS);
  return pyobj;
}


SWIGINTERN int Swig_var_YieldType_YIELD_TO_AVERAGE_MATURITY_THE_YIELD_ACHIEVED_BY_SUBSTITUTING_A_BONDS_AVERAGE_MATURITY_FOR_THE_ISSUES_FINAL_MATURITY_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable YieldType_YIELD_TO_AVERAGE_MATURITY_THE_YIELD_ACHIEVED_BY_SUBSTITUTING_A_BONDS_AVERAGE_MATURITY_FOR_THE_ISSUES_FINAL_MATURITY_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_YieldType_YIELD_TO_AVERAGE_MATURITY_THE_YIELD_ACHIEVED_BY_SUBSTITUTING_A_BONDS_AVERAGE_MATURITY_FOR_THE_ISSUES_FINAL_MATURITY_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::YieldType_YIELD_TO_AVERAGE_MATURITY_THE_YIELD_ACHIEVED_BY_SUBSTITUTING_A_BONDS_AVERAGE_MATURITY_FOR_THE_ISSUES_FINAL_MATURITY_DATE);
  return pyobj;
}


SWIGINTERN int Swig_var_PegScope_NATIONAL_XXCLUDING_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_NATIONAL_XXCLUDING_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegScope_NATIONAL_XXCLUDING_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegScope_NATIONAL_XXCLUDING_LOCAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PegScope_NATIONAL_EXCLUDING_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_NATIONAL_EXCLUDING_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegScope_NATIONAL_EXCLUDING_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegScope_NATIONAL_EXCLUDING_LOCAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PegScope_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegScope_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegScope_LOCAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PegScope_GLOBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_GLOBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegScope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegScope_GLOBAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PegScope_NATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegScope_NATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegScope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegScope_NATIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlDeliveryType_TRI_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_TRI_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlDeliveryType_TRI_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_TRI_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlDeliveryType_HOLD_IN_CUSTODY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_HOLD_IN_CUSTODY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlDeliveryType_HOLD_IN_CUSTODY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_HOLD_IN_CUSTODY));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlDeliveryType_FREE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_FREE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlDeliveryType_FREE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_FREE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlDeliveryType_VERSUS_PAYMENT_DELIVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_VERSUS_PAYMENT_DELIVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlDeliveryType_VERSUS_PAYMENT_DELIVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_VERSUS_PAYMENT_DELIVER));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlDeliveryType_FREE_DELIVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_FREE_DELIVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlDeliveryType_FREE_DELIVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_FREE_DELIVER));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlDeliveryType_VERSUS_PAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlDeliveryType_VERSUS_PAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlDeliveryType_VERSUS_PAYMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlDeliveryType_VERSUS_PAYMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionLimitType_STRICT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionLimitType_STRICT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionLimitType_STRICT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_STRICT));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionLimitType_OR_BETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionLimitType_OR_BETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionLimitType_OR_BETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_OR_BETTER));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionLimitType_OR_WORSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionLimitType_OR_WORSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionLimitType_OR_WORSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_OR_WORSE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionLimitType_OR_WORSE_FOR_A_BUY_THE_DISCRETION_PRICE_IS_A_MINIMUM_AND_FOR_A_SELL_THE_DISCRETION_PRICE_IS_A_MAXIMUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionLimitType_OR_WORSE_FOR_A_BUY_THE_DISCRETION_PRICE_IS_A_MINIMUM_AND_FOR_A_SELL_THE_DISCRETION_PRICE_IS_A_MAXIMUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionLimitType_OR_WORSE_FOR_A_BUY_THE_DISCRETION_PRICE_IS_A_MINIMUM_AND_FOR_A_SELL_THE_DISCRETION_PRICE_IS_A_MAXIMUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionLimitType_OR_WORSE_FOR_A_BUY_THE_DISCRETION_PRICE_IS_A_MINIMUM_AND_FOR_A_SELL_THE_DISCRETION_PRICE_IS_A_MAXIMUM));
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseMethod_AUTOMATIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseMethod_AUTOMATIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseMethod_AUTOMATIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExerciseMethod_AUTOMATIC));
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseMethod_MANUAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseMethod_MANUAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseMethod_MANUAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExerciseMethod_MANUAL));
  return pyobj;
}


SWIGINTERN int Swig_var_WorkingIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable WorkingIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_WorkingIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::WorkingIndicator_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_WorkingIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable WorkingIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_WorkingIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::WorkingIndicator_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_SideMultiLegReportingType_MULTILEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideMultiLegReportingType_MULTILEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideMultiLegReportingType_MULTILEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_MULTILEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_SideMultiLegReportingType_SINGLE_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideMultiLegReportingType_SINGLE_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideMultiLegReportingType_SINGLE_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_SINGLE_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_SideMultiLegReportingType_MULTI_LEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideMultiLegReportingType_MULTI_LEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideMultiLegReportingType_MULTI_LEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_MULTI_LEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmRejReason_MISMATCHED_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmRejReason_MISMATCHED_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmRejReason_MISMATCHED_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmRejReason_MISMATCHED_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_BidRequestTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidRequestTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidRequestTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidRequestTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_BidRequestTransType_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidRequestTransType_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidRequestTransType_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidRequestTransType_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_BidRequestTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidRequestTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidRequestTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BidRequestTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollApplType_GENERAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollApplType_GENERAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollApplType_GENERAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollApplType_GENERAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollApplType_SPECIFIC_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollApplType_SPECIFIC_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollApplType_SPECIFIC_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollApplType_SPECIFIC_DEPOSIT));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmType_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmType_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmType_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmType_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmType_CONFIRMATION_REQUEST_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmType_CONFIRMATION_REQUEST_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmType_CONFIRMATION_REQUEST_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmType_CONFIRMATION_REQUEST_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmType_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmType_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmType_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmType_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDQuoteType_INDICATIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_INDICATIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDQuoteType_INDICATIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_INDICATIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDQuoteType_RESTRICTED_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_RESTRICTED_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDQuoteType_RESTRICTED_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_RESTRICTED_TRADEABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDQuoteType_INDICATIVE_AND_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_INDICATIVE_AND_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDQuoteType_INDICATIVE_AND_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_INDICATIVE_AND_TRADEABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDQuoteType_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDQuoteType_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_TRADEABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDQuoteType_COUNTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDQuoteType_COUNTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDQuoteType_COUNTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDQuoteType_COUNTER));
  return pyobj;
}


SWIGINTERN int Swig_var_QtyType_CONTRACTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QtyType_CONTRACTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QtyType_CONTRACTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QtyType_CONTRACTS));
  return pyobj;
}


SWIGINTERN int Swig_var_QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_QtyType_UNITS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QtyType_UNITS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QtyType_UNITS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QtyType_UNITS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_END_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_END_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_END_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_END_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_COVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_COVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_COVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_COVER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_HIT_LIFT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_HIT_LIFT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_HIT_LIFT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_HIT_LIFT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_DONE_AWAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_DONE_AWAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_DONE_AWAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_DONE_AWAY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_TIMED_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_TIMED_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_TIMED_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_TIMED_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_PASS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_PASS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_PASS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_PASS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRespType_COUNTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRespType_COUNTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRespType_COUNTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRespType_COUNTER));
  return pyobj;
}


SWIGINTERN int Swig_var_IOINaturalFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOINaturalFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOINaturalFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOINaturalFlag_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_IOINaturalFlag_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOINaturalFlag_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOINaturalFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOINaturalFlag_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligSource_INSTRUCTIONS_OF_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligSource_INSTRUCTIONS_OF_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligSource_INSTRUCTIONS_OF_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligSource_INSTRUCTIONS_OF_BROKER));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligSource_INVESTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligSource_INVESTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligSource_INVESTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligSource_INVESTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_ON_HOURS_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_ON_HOURS_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_ON_HOURS_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ON_HOURS_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_INTERIM_PROTECTED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_INTERIM_PROTECTED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_INTERIM_PROTECTED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_INTERIM_PROTECTED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_K_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_K is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_K_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_K));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_LC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_LC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_LC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_LC));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_WN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_WN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_WN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_WN));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_CONVERTED_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_CONVERTED_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_CONVERTED_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CONVERTED_SWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_B_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_B is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_B_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_B));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_M_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_M is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_M_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_M));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_RT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_RT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_RT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_RT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_ONSET_DUE_TO_AN_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_ONSET_DUE_TO_AN_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_ONSET_DUE_TO_AN_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ONSET_DUE_TO_AN_ALLOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_CMTA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_CMTA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_CMTA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CMTA));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_DIFFERENTIAL_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_DIFFERENTIAL_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_DIFFERENTIAL_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_DIFFERENTIAL_SPREAD));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_TRANSACTION_FROM_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_TRANSACTION_FROM_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_TRANSACTION_FROM_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_TRANSACTION_FROM_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_TRANSACTION_FROM_ASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_TRANSACTION_FROM_ASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_TRANSACTION_FROM_ASSIGNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_TRANSACTION_FROM_ASSIGNMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_N_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_N is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_N_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_N));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_NR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_NR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_NR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_NR));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_SW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_SW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_SW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_SW));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_OTC_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_OTC_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_OTC_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_OTC_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_ADVISORY_FOR_CONTRA_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_ADVISORY_FOR_CONTRA_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_ADVISORY_FOR_CONTRA_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ADVISORY_FOR_CONTRA_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_P_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_P is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_P_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_P));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_CROSSED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_CROSSED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_CROSSED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_CROSSED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_PA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_PA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_PA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PA));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_R_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_R is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_R_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_R));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_RO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_RO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_RO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_RO));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_WT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_WT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_WT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_WT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_OFF_HOURS_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_OFF_HOURS_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_OFF_HOURS_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_OFF_HOURS_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_REJECT_FOR_SUBMITTING_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_REJECT_FOR_SUBMITTING_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_REJECT_FOR_SUBMITTING_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_REJECT_FOR_SUBMITTING_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_ONSET_DUT_TO_AN_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_ONSET_DUT_TO_AN_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_ONSET_DUT_TO_AN_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ONSET_DUT_TO_AN_ALLOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_AI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_AI is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_AI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_AI));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_PC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_PC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_PC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PC));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_PN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_PN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_PN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_PN));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_LARGE_IN_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_LARGE_IN_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_LARGE_IN_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_LARGE_IN_SCALE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_NM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_NM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_NM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_NM));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_T_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_T is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_T_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_T));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdSubType_ACATS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdSubType_ACATS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdSubType_ACATS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdSubType_ACATS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTransType_CORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTransType_CORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTransType_CORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecTransType_CORRECT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecTransType_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecTransType_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecTransType_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecTransType_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_DayBookingInst_ACCUMULATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DayBookingInst_ACCUMULATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DayBookingInst_ACCUMULATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_ACCUMULATE));
  return pyobj;
}


SWIGINTERN int Swig_var_DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_NERC_EASTERN_OFF_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_NERC_EASTERN_OFF_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_NERC_EASTERN_OFF_PEAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_EASTERN_OFF_PEAK));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_NERC_WESTERN_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_NERC_WESTERN_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_NERC_WESTERN_PEAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_WESTERN_PEAK));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_NERC_EASTERN_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_NERC_EASTERN_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_NERC_EASTERN_PEAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_EASTERN_PEAK));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH));
  return pyobj;
}


SWIGINTERN int Swig_var_FlowScheduleType_NERC_WESTERN_OFF_PEAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FlowScheduleType_NERC_WESTERN_OFF_PEAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FlowScheduleType_NERC_WESTERN_OFF_PEAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::FlowScheduleType_NERC_WESTERN_OFF_PEAK));
  return pyobj;
}


SWIGINTERN int Swig_var_MDOriginType_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDOriginType_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDOriginType_OFF_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_OFF_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDOriginType_OFF_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_OFF_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_MDOriginType_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDOriginType_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDOriginType_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDOriginType_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryStatus_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryStatus_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_COMPLETED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryStatus_ACCEPTED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_ACCEPTED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryStatus_ACCEPTED_WITH_WARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_ACCEPTED_WITH_WARNINGS));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollInquiryStatus_COMPLETED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollInquiryStatus_COMPLETED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollInquiryStatus_COMPLETED_WITH_WARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollInquiryStatus_COMPLETED_WITH_WARNINGS));
  return pyobj;
}


SWIGINTERN int Swig_var_CPProgram_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CPProgram_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_CPProgram_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CPProgram_3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_3));
  return pyobj;
}


SWIGINTERN int Swig_var_CPProgram_4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CPProgram_4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CPProgram_4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CPProgram_4));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_BACKOUT_MESSAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_BACKOUT_MESSAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_BACKOUT_MESSAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_BACKOUT_MESSAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_DELTA_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_DELTA_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_DELTA_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_DELTA_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_SETTLEMENT_ACTIVITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_SETTLEMENT_ACTIVITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_SETTLEMENT_ACTIVITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_SETTLEMENT_ACTIVITY));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_EXERCISES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_EXERCISES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_EXERCISES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_EXERCISES));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqType_ASSIGNMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqType_ASSIGNMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqType_ASSIGNMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqType_ASSIGNMENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_SECURITY_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_SECURITY_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ALL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ALL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ALL_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ALL_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES));
  return pyobj;
}


SWIGINTERN int Swig_var_SubscriptionRequestType_SNAPSHOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SubscriptionRequestType_SNAPSHOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SubscriptionRequestType_SNAPSHOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SubscriptionRequestType_SNAPSHOT));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsCategory_MARKETPLACE_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_MARKETPLACE_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsCategory_MARKETPLACE_NEWS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsCategory_MARKETPLACE_NEWS));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsCategory_TECHNICAL_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_TECHNICAL_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsCategory_TECHNICAL_NEWS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsCategory_TECHNICAL_NEWS));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsCategory_COMPANY_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_COMPANY_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsCategory_COMPANY_NEWS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsCategory_COMPANY_NEWS));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsCategory_OTHER_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_OTHER_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsCategory_OTHER_NEWS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsCategory_OTHER_NEWS));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsCategory_FINANCIAL_MARKET_NEWS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsCategory_FINANCIAL_MARKET_NEWS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsCategory_FINANCIAL_MARKET_NEWS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsCategory_FINANCIAL_MARKET_NEWS));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQty_MEDIUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQty_MEDIUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQty_MEDIUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIQty_MEDIUM);
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQty_LARGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQty_LARGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQty_LARGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIQty_LARGE);
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQty_SMALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQty_SMALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQty_SMALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIQty_SMALL);
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQty_UNDISCLOSED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQty_UNDISCLOSED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQty_UNDISCLOSED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::IOIQty_UNDISCLOSED_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplResponseError_APPLICATION_DOES_NOT_EXIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseError_APPLICATION_DOES_NOT_EXIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplResponseError_APPLICATION_DOES_NOT_EXIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplResponseError_APPLICATION_DOES_NOT_EXIST));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_DOWN_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_DOWN_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_DOWN_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_DOWN_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_UP_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_UP_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_UP_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_UP_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_LIQUIDITY_ROUTED_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_LIQUIDITY_ROUTED_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_LIQUIDITY_ROUTED_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_LIQUIDITY_ROUTED_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_AUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_ADDED_LIQUIDITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_ADDED_LIQUIDITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_ADDED_LIQUIDITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_ADDED_LIQUIDITY));
  return pyobj;
}


SWIGINTERN int Swig_var_LastLiquidityInd_REMOVED_LIQUIDITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastLiquidityInd_REMOVED_LIQUIDITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastLiquidityInd_REMOVED_LIQUIDITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LastLiquidityInd_REMOVED_LIQUIDITY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_OF_UNDERLYING_SETTLEMENT_PRICE_ACROSS_THE_LIFE_OF_THE_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_OF_UNDERLYING_SETTLEMENT_PRICE_ACROSS_THE_LIFE_OF_THE_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_OF_UNDERLYING_SETTLEMENT_PRICE_ACROSS_THE_LIFE_OF_THE_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_OF_UNDERLYING_SETTLEMENT_PRICE_ACROSS_THE_LIFE_OF_THE_OPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceDeterminationMethod_FIXED_STRIKE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceDeterminationMethod_FIXED_STRIKE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceDeterminationMethod_FIXED_STRIKE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceDeterminationMethod_FIXED_STRIKE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_TargetStrategy_PARTICIPATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TargetStrategy_PARTICIPATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TargetStrategy_PARTICIPATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_PARTICIPATE));
  return pyobj;
}


SWIGINTERN int Swig_var_TargetStrategy_MININIZE_MARKET_IMPACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TargetStrategy_MININIZE_MARKET_IMPACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TargetStrategy_MININIZE_MARKET_IMPACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_MININIZE_MARKET_IMPACT));
  return pyobj;
}


SWIGINTERN int Swig_var_TargetStrategy_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TargetStrategy_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TargetStrategy_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TargetStrategy_VWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_DueToRelated_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DueToRelated_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DueToRelated_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DueToRelated_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_DueToRelated_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DueToRelated_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DueToRelated_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DueToRelated_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingCashType_DIFF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingCashType_DIFF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingCashType_DIFF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnderlyingCashType_DIFF);
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingCashType_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingCashType_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingCashType_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnderlyingCashType_FIXED);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderCapacity_ALL_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderCapacity_ALL_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderCapacity_ALL_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CustOrderCapacity_ALL_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnershipType_JOINT_TRUSTEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnershipType_JOINT_TRUSTEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnershipType_JOINT_TRUSTEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OwnershipType_JOINT_TRUSTEES));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnershipType_JOINT_INVESTORS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnershipType_JOINT_INVESTORS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnershipType_JOINT_INVESTORS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OwnershipType_JOINT_INVESTORS));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnershipType_TENANTS_IN_COMMON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnershipType_TENANTS_IN_COMMON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnershipType_TENANTS_IN_COMMON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OwnershipType_TENANTS_IN_COMMON));
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_US_DOLLARS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_US_DOLLARS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_US_DOLLARS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_US_DOLLARS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_TONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_TONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_TONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_TONS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_TROY_OUNCES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_TROY_OUNCES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_TROY_OUNCES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_TROY_OUNCES);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_MEGAWATT_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MEGAWATT_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_MEGAWATT_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MEGAWATT_HOURS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_ONE_MILLION_BTU_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_ONE_MILLION_BTU is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_ONE_MILLION_BTU_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_ONE_MILLION_BTU);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_BILLION_CUBIC_FEET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_BILLION_CUBIC_FEET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_BILLION_CUBIC_FEET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_BILLION_CUBIC_FEET);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_MILLION_BARRELS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_MILLION_BARRELS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_MILLION_BARRELS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_MILLION_BARRELS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_GALLONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_GALLONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_GALLONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_GALLONS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_BARRELS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_BARRELS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_BARRELS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_BARRELS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_POUNDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_POUNDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_POUNDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_POUNDS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_METRIC_TONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_METRIC_TONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_METRIC_TONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_METRIC_TONS);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_ALLOWANCES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_ALLOWANCES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_ALLOWANCES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_ALLOWANCES);
  return pyobj;
}


SWIGINTERN int Swig_var_UnitOfMeasure_BUSHELS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnitOfMeasure_BUSHELS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnitOfMeasure_BUSHELS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::UnitOfMeasure_BUSHELS);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_WHEN_AND_IF_ISSUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_WHEN_AND_IF_ISSUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_WHEN_AND_IF_ISSUED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_WHEN_AND_IF_ISSUED));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_T_PLUS_1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T_PLUS_1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_T_PLUS_1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T_PLUS_1));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_FUTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_FUTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_FUTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_FUTURE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_SELLERS_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_SELLERS_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_SELLERS_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_SELLERS_OPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_T_PLUS_2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T_PLUS_2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_T_PLUS_2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T_PLUS_2));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_T_PLUS_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T_PLUS_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_T_PLUS_3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T_PLUS_3));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_T_PLUS_4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T_PLUS_4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_T_PLUS_4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T_PLUS_4));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_REGULAR));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_T_PLUS_5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_T_PLUS_5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_T_PLUS_5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_T_PLUS_5));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_WHEN_ISSUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_WHEN_ISSUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_WHEN_ISSUED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_WHEN_ISSUED));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_NEXT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_NEXT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_NEXT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_NEXT_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlmntTyp_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlmntTyp_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlmntTyp_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlmntTyp_CASH));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePublishIndicator_DO_NOT_PUBLISH_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePublishIndicator_DO_NOT_PUBLISH_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePublishIndicator_DO_NOT_PUBLISH_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePublishIndicator_DO_NOT_PUBLISH_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePublishIndicator_DEFERRED_PUBLICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePublishIndicator_DEFERRED_PUBLICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePublishIndicator_DEFERRED_PUBLICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePublishIndicator_DEFERRED_PUBLICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradePublishIndicator_PUBLISH_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradePublishIndicator_PUBLISH_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradePublishIndicator_PUBLISH_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradePublishIndicator_PUBLISH_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplResponseType_MESSAGES_NOT_AVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseType_MESSAGES_NOT_AVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplResponseType_MESSAGES_NOT_AVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplResponseType_MESSAGES_NOT_AVAILABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplResponseType_APPLICATION_DOES_NOT_EXIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseType_APPLICATION_DOES_NOT_EXIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplResponseType_APPLICATION_DOES_NOT_EXIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplResponseType_APPLICATION_DOES_NOT_EXIST));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED));
  return pyobj;
}


SWIGINTERN int Swig_var_StandInstDbType_DTC_SID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_DTC_SID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StandInstDbType_DTC_SID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_DTC_SID));
  return pyobj;
}


SWIGINTERN int Swig_var_StandInstDbType_ACCOUNTNET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_ACCOUNTNET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StandInstDbType_ACCOUNTNET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_ACCOUNTNET));
  return pyobj;
}


SWIGINTERN int Swig_var_StandInstDbType_A_GLOBAL_CUSTODIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_A_GLOBAL_CUSTODIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StandInstDbType_A_GLOBAL_CUSTODIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_A_GLOBAL_CUSTODIAN));
  return pyobj;
}


SWIGINTERN int Swig_var_StandInstDbType_THOMSON_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_THOMSON_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StandInstDbType_THOMSON_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_THOMSON_ALERT));
  return pyobj;
}


SWIGINTERN int Swig_var_StandInstDbType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StandInstDbType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StandInstDbType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StandInstDbType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_CROSS_MARKET_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_CROSS_MARKET_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_CROSS_MARKET_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_CROSS_MARKET_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_LOCKED_MARKET_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_LOCKED_MARKET_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_LOCKED_MARKET_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_LOCKED_MARKET_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_REMOVED_FROM_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_REMOVED_FROM_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_REMOVED_FROM_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_REMOVED_FROM_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteEntryStatus_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteEntryStatus_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteEntryStatus_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteEntryStatus_ACTIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceType_BEST_MID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_BEST_MID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceType_BEST_MID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_MID));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceType_BEST_BID_OR_LAST_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_BEST_BID_OR_LAST_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceType_BEST_BID_OR_LAST_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_BID_OR_LAST_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceType_BEST_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_BEST_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceType_BEST_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_BID));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceType_BEST_OFFER_OR_LAST_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_BEST_OFFER_OR_LAST_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceType_BEST_OFFER_OR_LAST_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_OFFER_OR_LAST_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceType_BEST_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_BEST_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceType_BEST_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_BEST_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceType_LAST_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceType_LAST_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceType_LAST_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceType_LAST_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstReqRejCode_UNKNOWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstReqRejCode_UNKNOWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstReqRejCode_UNKNOWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_UNKNOWN_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstReqRejCode_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstReqRejCode_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstReqRejCode_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SettlInstReqRejCode_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_Urgency_FLASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Urgency_FLASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Urgency_FLASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Urgency_FLASH));
  return pyobj;
}


SWIGINTERN int Swig_var_Urgency_NORMAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Urgency_NORMAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Urgency_NORMAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Urgency_NORMAL));
  return pyobj;
}


SWIGINTERN int Swig_var_Urgency_BACKGROUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Urgency_BACKGROUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Urgency_BACKGROUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Urgency_BACKGROUND));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnTransType_REVERSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_REVERSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnTransType_REVERSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_REVERSE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnTransType_RELEASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnTransType_RELEASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnTransType_RELEASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnTransType_RELEASE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_FED_WIRE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_FED_WIRE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_FED_WIRE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_FED_WIRE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_EUROCLEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_EUROCLEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_EUROCLEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_EUROCLEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_ACH_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_ACH_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_ACH_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_ACH_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_TELEGRAPHIC_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_TELEGRAPHIC_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_TELEGRAPHIC_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_TELEGRAPHIC_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_FEDWIRE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_FEDWIRE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_FEDWIRE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_FEDWIRE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_DIRECT_DEBIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_DIRECT_DEBIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_DIRECT_DEBIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DIRECT_DEBIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_CREDIT_CARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CREDIT_CARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_CREDIT_CARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CREDIT_CARD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_CHEQUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CHEQUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_CHEQUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CHEQUE));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_DIRECT_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_DIRECT_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_DIRECT_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DIRECT_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_CREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_CREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CREST));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_CLEARSTREAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_CLEARSTREAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_CLEARSTREAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_CLEARSTREAM));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_BPAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_BPAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_BPAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_BPAY));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_NSCC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_NSCC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_NSCC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_NSCC));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_DEBIT_CARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_DEBIT_CARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_DEBIT_CARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_DEBIT_CARD));
  return pyobj;
}


SWIGINTERN int Swig_var_PaymentMethod_ACH_DEBIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PaymentMethod_ACH_DEBIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PaymentMethod_ACH_DEBIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PaymentMethod_ACH_DEBIT));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceTypeScope_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceTypeScope_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceTypeScope_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_LOCAL));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceTypeScope_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceTypeScope_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceTypeScope_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceTypeScope_GLOBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceTypeScope_GLOBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceTypeScope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_GLOBAL));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerPriceTypeScope_NATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerPriceTypeScope_NATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerPriceTypeScope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerPriceTypeScope_NATIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_PegLimitType_STRICT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegLimitType_STRICT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegLimitType_STRICT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegLimitType_STRICT));
  return pyobj;
}


SWIGINTERN int Swig_var_PegLimitType_OR_BETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegLimitType_OR_BETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegLimitType_OR_BETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegLimitType_OR_BETTER));
  return pyobj;
}


SWIGINTERN int Swig_var_PegLimitType_OR_WORSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegLimitType_OR_WORSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegLimitType_OR_WORSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegLimitType_OR_WORSE));
  return pyobj;
}


SWIGINTERN int Swig_var_PegLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_PegLimitType_OR_WORSE_FOR_A_BUY_THE_PEG_LIMIT_IS_A_MINIMUM_AND_FOR_A_SELL_THE_PEG_LIMIT_IS_A_MAXIMUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegLimitType_OR_WORSE_FOR_A_BUY_THE_PEG_LIMIT_IS_A_MINIMUM_AND_FOR_A_SELL_THE_PEG_LIMIT_IS_A_MAXIMUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegLimitType_OR_WORSE_FOR_A_BUY_THE_PEG_LIMIT_IS_A_MINIMUM_AND_FOR_A_SELL_THE_PEG_LIMIT_IS_A_MAXIMUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegLimitType_OR_WORSE_FOR_A_BUY_THE_PEG_LIMIT_IS_A_MINIMUM_AND_FOR_A_SELL_THE_PEG_LIMIT_IS_A_MAXIMUM));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_BORROW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_BORROW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_BORROW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_BORROW));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_BUY_MINUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_BUY_MINUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_BUY_MINUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_BUY_MINUS));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_SUBSCRIBE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SUBSCRIBE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_SUBSCRIBE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SUBSCRIBE));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_CROSS_SHORT_EXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_CROSS_SHORT_EXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_CROSS_SHORT_EXEMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_CROSS_SHORT_EXEMPT));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_UNDISCLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_UNDISCLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_UNDISCLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_UNDISCLOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_SELL_SHORT_EXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELL_SHORT_EXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_SELL_SHORT_EXEMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELL_SHORT_EXEMPT));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_BUY));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_CROSS_SHORT_EXXMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_CROSS_SHORT_EXXMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_CROSS_SHORT_EXXMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_CROSS_SHORT_EXXMPT));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELL));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_LEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_LEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_LEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_LEND));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_SELL_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELL_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_SELL_SHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELL_SHORT));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_OPPOSITE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_OPPOSITE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_OPPOSITE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_OPPOSITE));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_CROSS_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_CROSS_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_CROSS_SHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_CROSS_SHORT));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_SELL_PLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_SELL_PLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_SELL_PLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_SELL_PLUS));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_REDEEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_REDEEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_REDEEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_REDEEM));
  return pyobj;
}


SWIGINTERN int Swig_var_Side_AS_DEFINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Side_AS_DEFINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Side_AS_DEFINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Side_AS_DEFINED));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_EXIT_CHARGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_EXIT_CHARGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_EXIT_CHARGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_EXIT_CHARGE));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_DILUTION_LEVY_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DILUTION_LEVY_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_DILUTION_LEVY_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DILUTION_LEVY_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_DILUTION_LEVY_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DILUTION_LEVY_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_DILUTION_LEVY_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DILUTION_LEVY_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_DISCOUNT_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DISCOUNT_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_DISCOUNT_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNT_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_COMMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_COMMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_COMMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSION));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_INITIAL_CHARGE_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_INITIAL_CHARGE_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_INITIAL_CHARGE_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_INITIAL_CHARGE_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_DILUTION_LEVY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DILUTION_LEVY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_DILUTION_LEVY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DILUTION_LEVY));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_COMMISSION_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_COMMISSION_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_COMMISSION_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSION_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_NET_SETTLEMENT_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_NET_SETTLEMENT_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_NET_SETTLEMENT_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_NET_SETTLEMENT_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_FUND_BASED_RENEWAL_COMMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUND_BASED_RENEWAL_COMMISSION));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_DISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_DISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_EXIT_CHARGE_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_EXIT_CHARGE_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_EXIT_CHARGE_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_EXIT_CHARGE_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_INITIAL_CHARGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_INITIAL_CHARGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_INITIAL_CHARGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_INITIAL_CHARGE));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_DISCOUNT_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_DISCOUNT_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_DISCOUNT_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_DISCOUNT_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_EXIT_CHARGE_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_EXIT_CHARGE_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_EXIT_CHARGE_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_EXIT_CHARGE_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_COMMISSION_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_COMMISSION_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_COMMISSION_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_COMMISSION_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_PROJECTED_FUND_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_PROJECTED_FUND_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_PROJECTED_FUND_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_PROJECTED_FUND_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_ContAmtType_INITIAL_CHARGE_AMOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContAmtType_INITIAL_CHARGE_AMOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContAmtType_INITIAL_CHARGE_AMOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContAmtType_INITIAL_CHARGE_AMOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_IMPLIED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_IMPLIED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_IMPLIED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_IMPLIED_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_STREAMING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_STREAMING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_STREAMING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_STREAMING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_QUOTE_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_QUOTE_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_QUOTE_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_QUOTE_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_CROSS_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_CROSS_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_CROSS_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_CROSS_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_MULTILEG_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_MULTILEG_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_MULTILEG_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_MULTILEG_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_PRIVATELY_NEGOTIATED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_PRIVATELY_NEGOTIATED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_PRIVATELY_NEGOTIATED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_PRIVATELY_NEGOTIATED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderCategory_LINKED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderCategory_LINKED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderCategory_LINKED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrderCategory_LINKED_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_AdvTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdvTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::AdvTransType_REPLACE);
  return pyobj;
}


SWIGINTERN int Swig_var_AdvTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdvTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::AdvTransType_NEW);
  return pyobj;
}


SWIGINTERN int Swig_var_AdvTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AdvTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AdvTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::AdvTransType_CANCEL);
  return pyobj;
}


SWIGINTERN int Swig_var_PublishTrdIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PublishTrdIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PublishTrdIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PublishTrdIndicator_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_PublishTrdIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PublishTrdIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PublishTrdIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PublishTrdIndicator_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_WITH_REVISIONS_AS_INDICATED_IN_THE_MESSAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_WITH_REVISIONS_AS_INDICATED_IN_THE_MESSAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_WITH_REVISIONS_AS_INDICATED_IN_THE_MESSAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_WITH_REVISIONS_AS_INDICATED_IN_THE_MESSAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityResponseType_REJECT_SECURITY_PROPOSAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_REJECT_SECURITY_PROPOSAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityResponseType_REJECT_SECURITY_PROPOSAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_REJECT_SECURITY_PROPOSAL));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_PASSWORD_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_PASSWORD_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_PASSWORD_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_PASSWORD_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_SESSION_LOGOUT_COMPLETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_SESSION_LOGOUT_COMPLETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_SESSION_LOGOUT_COMPLETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_SESSION_LOGOUT_COMPLETE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_INVALID_USERNAME_OR_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_INVALID_USERNAME_OR_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_INVALID_USERNAME_OR_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_INVALID_USERNAME_OR_PASSWORD));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_SESSION_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_SESSION_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_SESSION_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_SESSION_ACTIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_SESSION_PASSWORD_CHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_SESSION_PASSWORD_CHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_SESSION_PASSWORD_CHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_SESSION_PASSWORD_CHANGED));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_ACCOUNT_LOCKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_ACCOUNT_LOCKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_ACCOUNT_LOCKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_ACCOUNT_LOCKED));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_HOUSE_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_HOUSE_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_HOUSE_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_HOUSE_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_FLOOR_TRADER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_FLOOR_TRADER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_FLOOR_TRADER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_FLOOR_TRADER));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_JOINT_BACKOFFICE_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_JOINT_BACKOFFICE_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_JOINT_BACKOFFICE_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_JOINT_BACKOFFICE_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocTransType_CALCULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_CALCULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocTransType_CALCULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CALCULATED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocTransType_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocTransType_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocTransType_REVERSAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_REVERSAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocTransType_REVERSAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_REVERSAL));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocTransType_CALCULATED_WITHOUT_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocTransType_CALCULATED_WITHOUT_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocTransType_CALCULATED_WITHOUT_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocTransType_CALCULATED_WITHOUT_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationQtyType_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationQtyType_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationQtyType_FINAL_WILL_BE_EXERCISED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_FINAL_WILL_BE_EXERCISED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationQtyType_FINAL_WILL_BE_EXERCISED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_FINAL_WILL_BE_EXERCISED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationQtyType_NON_AUTO_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_NON_AUTO_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationQtyType_NON_AUTO_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_NON_AUTO_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationQtyType_CONTRARY_INTENTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_CONTRARY_INTENTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationQtyType_CONTRARY_INTENTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_CONTRARY_INTENTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExpirationQtyType_AUTO_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExpirationQtyType_AUTO_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExpirationQtyType_AUTO_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExpirationQtyType_AUTO_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocHandlInst_FORWARD_AND_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocHandlInst_FORWARD_AND_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocHandlInst_FORWARD_AND_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_FORWARD_AND_MATCH));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocHandlInst_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocHandlInst_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocHandlInst_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_FORWARD));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocHandlInst_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocHandlInst_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocHandlInst_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocHandlInst_MATCH));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestStatus_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestStatus_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestStatus_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_COMPLETED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeRequestStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeRequestStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeRequestStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeRequestStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST));
  return pyobj;
}


SWIGINTERN int Swig_var_PreallocMethod_PRO_RATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreallocMethod_PRO_RATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PreallocMethod_PRO_RATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PreallocMethod_PRO_RATA));
  return pyobj;
}


SWIGINTERN int Swig_var_PreallocMethod_DO_NOT_PRO_RATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreallocMethod_DO_NOT_PRO_RATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PreallocMethod_DO_NOT_PRO_RATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PreallocMethod_DO_NOT_PRO_RATA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_457_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_457 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_457_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_457));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_MAXI_ISA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MAXI_ISA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_MAXI_ISA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MAXI_ISA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EMPLOYEE_CURRENT_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYEE_CURRENT_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EMPLOYEE_CURRENT_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE_CURRENT_YEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EMPLOYEE_9_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYEE_9 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EMPLOYEE_9_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE_9));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_403_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_403 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_403_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_403));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_KEOGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_KEOGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_KEOGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_KEOGH));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_401K_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_401K is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_401K_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_401K));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_SELF_DIRECTED_IRA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_SELF_DIRECTED_IRA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_SELF_DIRECTED_IRA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_SELF_DIRECTED_IRA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_ROTH_IRA_24_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTH_IRA_24 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_ROTH_IRA_24_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTH_IRA_24));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_CURRENT_YEAR_PAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_CURRENT_YEAR_PAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_CURRENT_YEAR_PAYMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_CURRENT_YEAR_PAYMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_MINI_INSURANCE_ISA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MINI_INSURANCE_ISA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_MINI_INSURANCE_ISA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINI_INSURANCE_ISA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EDUCATION_IRA_28_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EDUCATION_IRA_28 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EDUCATION_IRA_28_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EDUCATION_IRA_28));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_ROTH_IRA_25_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTH_IRA_25 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_ROTH_IRA_25_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTH_IRA_25));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EMPLOYEE_10_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYEE_10 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EMPLOYEE_10_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE_10));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EDUCATION_IRA_29_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EDUCATION_IRA_29 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EDUCATION_IRA_29_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EDUCATION_IRA_29));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_PRIOR_YEAR_PAYMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_PRIOR_YEAR_PAYMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_PRIOR_YEAR_PAYMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_PRIOR_YEAR_PAYMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EMPLOYER_11_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYER_11 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EMPLOYER_11_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER_11));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_ASSET_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ASSET_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_ASSET_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ASSET_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EMPLOYER_12_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYER_12 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EMPLOYER_12_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER_12));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EMPLOYEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EMPLOYEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYEE));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_26_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTH_CONVERSION_IRA_26 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_26_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTH_CONVERSION_IRA_26));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_MINI_CASH_ISA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_MINI_CASH_ISA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_MINI_CASH_ISA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_MINI_CASH_ISA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_27_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_ROTH_CONVERSION_IRA_27 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_27_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_ROTH_CONVERSION_IRA_27));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_NONE_NOT_APPLICABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_NONE_NOT_APPLICABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_NONE_NOT_APPLICABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NONE_NOT_APPLICABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_TESSA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_TESSA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_TESSA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_TESSA));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_NON_FUND_QUALIFIED_PLAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_NON_FUND_QUALIFIED_PLAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_NON_FUND_QUALIFIED_PLAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NON_FUND_QUALIFIED_PLAN));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EMPLOYER_CURRENT_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYER_CURRENT_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EMPLOYER_CURRENT_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER_CURRENT_YEAR));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_EMPLOYER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_EMPLOYER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_EMPLOYER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_EMPLOYER));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_PROFIT_SHARING_PLAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_PROFIT_SHARING_PLAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_PROFIT_SHARING_PLAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_PROFIT_SHARING_PLAN));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_401_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_401 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_401_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_401));
  return pyobj;
}


SWIGINTERN int Swig_var_TaxAdvantageType_NON_FUND_PROTOTYPE_IRA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TaxAdvantageType_NON_FUND_PROTOTYPE_IRA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TaxAdvantageType_NON_FUND_PROTOTYPE_IRA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TaxAdvantageType_NON_FUND_PROTOTYPE_IRA));
  return pyobj;
}


SWIGINTERN int Swig_var_MessageEncoding_EUC_JP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_EUC_JP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MessageEncoding_EUC_JP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_EUC_JP);
  return pyobj;
}


SWIGINTERN int Swig_var_MessageEncoding_SHIFT_JIS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_SHIFT_JIS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MessageEncoding_SHIFT_JIS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_SHIFT_JIS);
  return pyobj;
}


SWIGINTERN int Swig_var_MessageEncoding_UTF_8_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_UTF_8 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MessageEncoding_UTF_8_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_UTF_8);
  return pyobj;
}


SWIGINTERN int Swig_var_MessageEncoding_ISO_2022_JP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_ISO_2022_JP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MessageEncoding_ISO_2022_JP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_ISO_2022_JP);
  return pyobj;
}


SWIGINTERN int Swig_var_MessageEncoding_EUC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_EUC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MessageEncoding_EUC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_EUC);
  return pyobj;
}


SWIGINTERN int Swig_var_MessageEncoding_JIS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_JIS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MessageEncoding_JIS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_JIS);
  return pyobj;
}


SWIGINTERN int Swig_var_MessageEncoding_FOR_USING_SJIS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_FOR_USING_SJIS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MessageEncoding_FOR_USING_SJIS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_FOR_USING_SJIS);
  return pyobj;
}


SWIGINTERN int Swig_var_MessageEncoding_UNICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MessageEncoding_UNICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MessageEncoding_UNICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MessageEncoding_UNICODE);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_GOOD_TILL_CROSSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_TILL_CROSSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_GOOD_TILL_CROSSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_TILL_CROSSING));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_FILL_OR_KILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_FILL_OR_KILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_FILL_OR_KILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_FILL_OR_KILL));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_GOOD_TILL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_TILL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_GOOD_TILL_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_TILL_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_GOOD_TILL_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_TILL_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_GOOD_TILL_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_TILL_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_AT_CROSSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_AT_CROSSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_AT_CROSSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_AT_CROSSING));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_IMMEDIATE_OR_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_IMMEDIATE_OR_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_IMMEDIATE_OR_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_IMMEDIATE_OR_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_GOOD_THROUGH_CROSSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_GOOD_THROUGH_CROSSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_GOOD_THROUGH_CROSSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_GOOD_THROUGH_CROSSING));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_AT_THE_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_AT_THE_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_AT_THE_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_AT_THE_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeInForce_AT_THE_OPENING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeInForce_AT_THE_OPENING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeInForce_AT_THE_OPENING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TimeInForce_AT_THE_OPENING));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_THROUGH_THE_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_THROUGH_THE_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_THROUGH_THE_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_THROUGH_THE_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_INDIDCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_INDIDCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_INDIDCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_INDIDCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_AT_THE_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AT_THE_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_AT_THE_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AT_THE_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_AT_THE_MIDPOINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AT_THE_MIDPOINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_AT_THE_MIDPOINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AT_THE_MIDPOINT));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_CROSSING_OPPORTUNITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_CROSSING_OPPORTUNITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_CROSSING_OPPORTUNITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_CROSSING_OPPORTUNITY));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_CURRENT_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_CURRENT_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_CURRENT_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_CURRENT_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_IN_TOUCH_WITH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_IN_TOUCH_WITH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_IN_TOUCH_WITH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_IN_TOUCH_WITH));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_ALL_OR_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_ALL_OR_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_TAKING_A_POSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_TAKING_A_POSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_TAKING_A_POSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_TAKING_A_POSITION));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_AT_THE_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AT_THE_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_AT_THE_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AT_THE_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_PORTFOLIO_SHOW_N_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_PORTFOLIO_SHOW_N is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_PORTFOLIO_SHOW_N_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PORTFOLIO_SHOW_N));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_MARKET_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_MARKET_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_MARKET_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_MARKET_ON_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_VERSUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_VERSUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_VERSUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_VERSUS));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_PORTFOLIO_SHOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_PORTFOLIO_SHOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_PORTFOLIO_SHOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PORTFOLIO_SHOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_READY_TO_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_READY_TO_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_READY_TO_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_READY_TO_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_PRE_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_PRE_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_PRE_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_PRE_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_INDICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_INDICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_INDICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_INDICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_MORE_BEHIND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_MORE_BEHIND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_MORE_BEHIND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_MORE_BEHIND));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_VWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIQualifier_AT_THE_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIQualifier_AT_THE_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIQualifier_AT_THE_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIQualifier_AT_THE_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_UNDERLYING_IS_IN_THE_MONEY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceBoundaryMethod_GREATER_THAN_UNDERLYING_IS_IN_THE_MONEY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_UNDERLYING_IS_IN_THE_MONEY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_GREATER_THAN_UNDERLYING_IS_IN_THE_MONEY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceBoundaryMethod_LESS_THAN_UNDERLYING_PRICE_IS_IN_THE_MONEY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceBoundaryMethod_LESS_THAN_UNDERLYING_PRICE_IS_IN_THE_MONEY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceBoundaryMethod_LESS_THAN_UNDERLYING_PRICE_IS_IN_THE_MONEY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_LESS_THAN_UNDERLYING_PRICE_IS_IN_THE_MONEY));
  return pyobj;
}


SWIGINTERN int Swig_var_StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY));
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_CONVERSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_CONVERSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_CONVERSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_CONVERSION);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_CONSUMPTION_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_CONSUMPTION_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_CONSUMPTION_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_CONSUMPTION_TAX);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_LOCAL_COMMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_LOCAL_COMMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_LOCAL_COMMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_LOCAL_COMMISSION);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_TAX);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_MARKUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_MARKUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_MARKUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_MARKUP);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_SECURITY_LENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_SECURITY_LENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_SECURITY_LENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_SECURITY_LENDING);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_PER_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_PER_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_PER_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_PER_TRANSACTION);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_REGULATORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_REGULATORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_REGULATORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_REGULATORY);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_STAMP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_STAMP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_STAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_STAMP);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_TRANSFER_FEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_TRANSFER_FEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_TRANSFER_FEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_TRANSFER_FEE);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_AGENT);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_OTHER);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_EXCHANGE_FEES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_EXCHANGE_FEES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_EXCHANGE_FEES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_EXCHANGE_FEES);
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeType_LEVY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeType_LEVY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeType_LEVY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MiscFeeType_LEVY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_CLEARING_HOUSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_CLEARING_HOUSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_CLEARING_HOUSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_CLEARING_HOUSE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_EXCHANGE_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_EXCHANGE_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_EXCHANGE_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_EXCHANGE_SYMBOL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_SICOVAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_SICOVAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_SICOVAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_SICOVAM);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_ISDA_FPML_PRODUCT_URL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISDA_FPML_PRODUCT_URL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_ISDA_FPML_PRODUCT_URL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISDA_FPML_PRODUCT_URL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_RIC_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_RIC_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_RIC_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_RIC_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_ISO_CURRENCY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISO_CURRENCY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_ISO_CURRENCY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISO_CURRENCY_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_COMMON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_COMMON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_COMMON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_COMMON);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_VALOREN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_VALOREN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_VALOREN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_VALOREN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_BELGIAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_BELGIAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_BELGIAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_BELGIAN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_OPTIONS_PRICE_REPORTING_AUTHORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_OPTIONS_PRICE_REPORTING_AUTHORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_OPTIONS_PRICE_REPORTING_AUTHORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_OPTIONS_PRICE_REPORTING_AUTHORITY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_ISIN_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISIN_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_ISIN_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISIN_NUMBER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_SEDOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_SEDOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_SEDOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_SEDOL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_ISO_COUNTRY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_ISO_COUNTRY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_ISO_COUNTRY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_ISO_COUNTRY_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_LETTER_OF_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_LETTER_OF_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_LETTER_OF_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_LETTER_OF_CREDIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_BLOOMBERG_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_BLOOMBERG_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_BLOOMBERG_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_BLOOMBERG_SYMBOL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_WERTPAPIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_WERTPAPIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_WERTPAPIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_WERTPAPIER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_DUTCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_DUTCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_DUTCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_DUTCH);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_QUIK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_QUIK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_QUIK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_QUIK);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityIDSource_CUSIP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityIDSource_CUSIP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityIDSource_CUSIP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityIDSource_CUSIP);
  return pyobj;
}


SWIGINTERN int Swig_var_NewsRefType_OTHER_LANGUAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsRefType_OTHER_LANGUAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsRefType_OTHER_LANGUAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsRefType_OTHER_LANGUAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsRefType_COMPLIMENTARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsRefType_COMPLIMENTARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsRefType_COMPLIMENTARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsRefType_COMPLIMENTARY));
  return pyobj;
}


SWIGINTERN int Swig_var_NewsRefType_REPLACEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NewsRefType_REPLACEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NewsRefType_REPLACEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NewsRefType_REPLACEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerOrderType_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerOrderType_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerOrderType_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerOrderType_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_TriggerOrderType_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriggerOrderType_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriggerOrderType_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TriggerOrderType_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_IN_THE_CASE_OTHER_ORDERS_EXIST_WITH_THE_SAME_PRICE_THE_QUANTITY_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_EXISTING_ORDERS_AND_QUOTES_THE_REMAINDER_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_OTHER_SIDE_OF_THE_CROSS_THE_TWO_SIDES_POTENTIALLY_HAVE_DIFFERENT_QUANTITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_IN_THE_CASE_OTHER_ORDERS_EXIST_WITH_THE_SAME_PRICE_THE_QUANTITY_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_EXISTING_ORDERS_AND_QUOTES_THE_REMAINDER_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_OTHER_SIDE_OF_THE_CROSS_THE_TWO_SIDES_POTENTIALLY_HAVE_DIFFERENT_QUANTITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_IN_THE_CASE_OTHER_ORDERS_EXIST_WITH_THE_SAME_PRICE_THE_QUANTITY_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_EXISTING_ORDERS_AND_QUOTES_THE_REMAINDER_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_OTHER_SIDE_OF_THE_CROSS_THE_TWO_SIDES_POTENTIALLY_HAVE_DIFFERENT_QUANTITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_IN_THE_CASE_OTHER_ORDERS_EXIST_WITH_THE_SAME_PRICE_THE_QUANTITY_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_EXISTING_ORDERS_AND_QUOTES_THE_REMAINDER_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_OTHER_SIDE_OF_THE_CROSS_THE_TWO_SIDES_POTENTIALLY_HAVE_DIFFERENT_QUANTITIES));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CROSS_AON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_AON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CROSS_AON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_AON));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CROSS_TRADE_WHICH_IS_PARTIALLY_EXECUTED_WITH_THE_UNFILLED_PORTIONS_REMAINING_ACTIVE_ONE_SIDE_OF_THE_CROSS_IS_FULLY_EXECUTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_TRADE_WHICH_IS_PARTIALLY_EXECUTED_WITH_THE_UNFILLED_PORTIONS_REMAINING_ACTIVE_ONE_SIDE_OF_THE_CROSS_IS_FULLY_EXECUTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CROSS_TRADE_WHICH_IS_PARTIALLY_EXECUTED_WITH_THE_UNFILLED_PORTIONS_REMAINING_ACTIVE_ONE_SIDE_OF_THE_CROSS_IS_FULLY_EXECUTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_TRADE_WHICH_IS_PARTIALLY_EXECUTED_WITH_THE_UNFILLED_PORTIONS_REMAINING_ACTIVE_ONE_SIDE_OF_THE_CROSS_IS_FULLY_EXECUTED));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_COMPLETELY_OR_NOT_BOTH_SIDES_ARE_TREATED_IN_THE_SAME_MANNER_THIS_IS_EQUIVALENT_TO_AN_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_COMPLETELY_OR_NOT_BOTH_SIDES_ARE_TREATED_IN_THE_SAME_MANNER_THIS_IS_EQUIVALENT_TO_AN_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_COMPLETELY_OR_NOT_BOTH_SIDES_ARE_TREATED_IN_THE_SAME_MANNER_THIS_IS_EQUIVALENT_TO_AN_ALL_OR_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_COMPLETELY_OR_NOT_BOTH_SIDES_ARE_TREATED_IN_THE_SAME_MANNER_THIS_IS_EQUIVALENT_TO_AN_ALL_OR_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CROSS_ONE_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_ONE_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CROSS_ONE_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_ONE_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CROSS_SAME_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_SAME_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CROSS_SAME_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_SAME_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CROSS_IOC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_IOC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CROSS_IOC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_IOC));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_NOTE_THE_CROSSPRIORITZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_NOTE_THE_CROSSPRIORITZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_NOTE_THE_CROSSPRIORITZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_NOTE_THE_CROSSPRIORITZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettleFlag_SESSION_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettleFlag_SESSION_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettleFlag_SESSION_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_SESSION_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettleFlag_DAILY_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettleFlag_DAILY_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettleFlag_DAILY_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_DAILY_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettleFlag_EXPECTED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettleFlag_EXPECTED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettleFlag_EXPECTED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_EXPECTED_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDBookType_PRICE_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDBookType_PRICE_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDBookType_PRICE_DEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDBookType_PRICE_DEPTH));
  return pyobj;
}


SWIGINTERN int Swig_var_MDBookType_ORDER_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDBookType_ORDER_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDBookType_ORDER_DEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDBookType_ORDER_DEPTH));
  return pyobj;
}


SWIGINTERN int Swig_var_MDBookType_TOP_OF_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDBookType_TOP_OF_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDBookType_TOP_OF_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDBookType_TOP_OF_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAP_THROUGH_A_MORNING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_A_MORNING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CLOSING_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAP_THROUGH_A_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_A_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_OTHERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_OTHERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_OTHERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_OTHERS));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_CURRENT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_CURRENT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_CURRENT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_CURRENT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_SQ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_SQ is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_SQ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_SQ));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_STRIKE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_STRIKE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_STRIKE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_STRIKE));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI));
  return pyobj;
}


SWIGINTERN int Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_ROLLING_BARRIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_ROLLING_BARRIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_ROLLING_BARRIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_ROLLING_BARRIER));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_UNDERLYING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_UNDERLYING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_UNDERLYING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_UNDERLYING));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_KNOCK_OUT_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_KNOCK_OUT_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_KNOCK_OUT_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_KNOCK_OUT_UP));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_KNOCK_IN_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_KNOCK_IN_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_KNOCK_IN_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_KNOCK_IN_UP));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_KOCK_IN_DOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_KOCK_IN_DOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_KOCK_IN_DOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_KOCK_IN_DOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_TRIGGER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_TRIGGER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_TRIGGER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_TRIGGER));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_RESET_BARRIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_RESET_BARRIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_RESET_BARRIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_RESET_BARRIER));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_CAPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_CAPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_CAPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_CAPPED));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventType_KNOCK_OUT_DOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventType_KNOCK_OUT_DOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventType_KNOCK_OUT_DOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventType_KNOCK_OUT_DOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionResponse_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionResponse_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionResponse_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionResponse_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MassActionResponse_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassActionResponse_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassActionResponse_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MassActionResponse_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_REQUEST_LIST_SECURITY_TYPES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_REQUEST_LIST_SECURITY_TYPES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_REQUEST_LIST_SECURITY_TYPES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQUEST_LIST_SECURITY_TYPES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_REQUEST_LIST_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_REQUEST_LIST_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_REQUEST_LIST_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQUEST_LIST_SECURITIES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_TRADINGSESSIONID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_TRADINGSESSIONID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_TRADINGSESSIONID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_TRADINGSESSIONID));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_ALL_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_ALL_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_ALL_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_ALL_SECURITIES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ListRejectReason_EXCHANGE_CLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_EXCHANGE_CLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListRejectReason_EXCHANGE_CLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_EXCHANGE_CLOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_ListRejectReason_UNKNOWN_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_UNKNOWN_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListRejectReason_UNKNOWN_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_UNKNOWN_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC));
  return pyobj;
}


SWIGINTERN int Swig_var_ListRejectReason_DUPLICATE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_DUPLICATE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListRejectReason_DUPLICATE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_DUPLICATE_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_ListRejectReason_TOO_LATE_TO_ENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_TOO_LATE_TO_ENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListRejectReason_TOO_LATE_TO_ENTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_TOO_LATE_TO_ENTER));
  return pyobj;
}


SWIGINTERN int Swig_var_ListRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_ListRejectReason_BROKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListRejectReason_BROKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListRejectReason_BROKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListRejectReason_BROKER));
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_PROPRIETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_PROPRIETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_PROPRIETARY);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_ARBITRAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_ARBITRAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_ARBITRAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_ARBITRAGE);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_TRADING);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_DERIVATIVES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_DERIVATIVES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_DERIVATIVES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_DERIVATIVES);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_SALES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_SALES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_SALES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_SALES);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_INSTITUTIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_INSTITUTIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_INSTITUTIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_INSTITUTIONAL);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_INTERNATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_INTERNATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_INTERNATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_INTERNATIONAL);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_AGENCY);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_PREFERRED_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_PREFERRED_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_PREFERRED_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_PREFERRED_TRADING);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_OTHER);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskType_PROGRAM_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskType_PROGRAM_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskType_PROGRAM_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskType_PROGRAM_TRADING);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_WHEN_AND_IF_ISSUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_WHEN_AND_IF_ISSUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_WHEN_AND_IF_ISSUED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_WHEN_AND_IF_ISSUED);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_FUTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_FUTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_FUTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_FUTURE);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_BROKEN_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_BROKEN_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_BROKEN_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_BROKEN_DATE);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_SELLERS_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_SELLERS_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_SELLERS_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_SELLERS_OPTION);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_T_PLUS_2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T_PLUS_2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_T_PLUS_2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_2);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_T_PLUS_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T_PLUS_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_T_PLUS_3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_3);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_T_PLUS_4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T_PLUS_4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_T_PLUS_4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_4);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_REGULAR);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_FX_SPOT_NEXT_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_FX_SPOT_NEXT_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_FX_SPOT_NEXT_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_FX_SPOT_NEXT_SETTLEMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_T_PLUS_5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_T_PLUS_5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_T_PLUS_5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_T_PLUS_5);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_NEXT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_NEXT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_NEXT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_NEXT_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlType_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlType_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlType_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlType_CASH);
  return pyobj;
}


SWIGINTERN int Swig_var_OpenClose_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenClose_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenClose_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenClose_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_OpenClose_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OpenClose_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OpenClose_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OpenClose_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_ContractMultiplierUnit_SHARES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContractMultiplierUnit_SHARES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContractMultiplierUnit_SHARES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_SHARES));
  return pyobj;
}


SWIGINTERN int Swig_var_ContractMultiplierUnit_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContractMultiplierUnit_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContractMultiplierUnit_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_HOURS));
  return pyobj;
}


SWIGINTERN int Swig_var_ContractMultiplierUnit_DAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ContractMultiplierUnit_DAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ContractMultiplierUnit_DAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ContractMultiplierUnit_DAYS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_FUTURES_LARGE_ORDER_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_FUTURES_LARGE_ORDER_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_FUTURES_LARGE_ORDER_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_FUTURES_LARGE_ORDER_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_BLOCK_TRADE_38_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BLOCK_TRADE_38 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_BLOCK_TRADE_38_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCK_TRADE_38));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_DELTA_NEUTRAL_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_DELTA_NEUTRAL_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_DELTA_NEUTRAL_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_DELTA_NEUTRAL_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_LATE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_LATE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_LATE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_LATE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_CASH_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_CASH_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_CASH_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_CASH_SETTLEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_CUM_BONUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_BONUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_CUM_BONUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_BONUS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_BLOCK_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BLOCK_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_BLOCK_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCK_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_ALL_OR_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_ALL_OR_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_OPTION_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_OPTION_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_OPTION_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_OPTION_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_FINANCING_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_FINANCING_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_FINANCING_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_FINANCING_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_TRADING_AT_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_TRADING_AT_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_TRADING_AT_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_TRADING_AT_SETTLEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_EX_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_EX_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_EX_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_EX_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_COUPON));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_CUM_RIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_RIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_CUM_RIGHTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_RIGHTS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_EX_BONUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_BONUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_EX_BONUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_BONUS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_REGULAR_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_REGULAR_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_REGULAR_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_REGULAR_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EXCHANGE_GRANTED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_GRANTED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EXCHANGE_GRANTED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_GRANTED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EXCHANGE_BASIS_FACILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_BASIS_FACILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EXCHANGE_BASIS_FACILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_BASIS_FACILITY));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_BLOCK_TRADE_1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BLOCK_TRADE_1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_BLOCK_TRADE_1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCK_TRADE_1));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_ERROR_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_ERROR_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_ERROR_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_ERROR_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_NAME_CHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_NAME_CHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_NAME_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_NAME_CHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_LATE_BUNCHED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_LATE_BUNCHED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_LATE_BUNCHED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_LATE_BUNCHED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EFP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EFP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EFP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EFP));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_NON_STANDARD_SETTLEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_NON_STANDARD_SETTLEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_NON_STANDARD_SETTLEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_NON_STANDARD_SETTLEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EXCHANGE_FOR_RISK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_FOR_RISK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EXCHANGE_FOR_RISK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_FOR_RISK));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EXCHANGE_FOR_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_FOR_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EXCHANGE_FOR_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_FOR_SWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_OF_FUTURES_FOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_OF_FUTURES_FOR));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_OPTION_INTERIM_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_OPTION_INTERIM_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_OPTION_INTERIM_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_OPTION_INTERIM_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_PRIVATELY_NEGOTIATED_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PRIVATELY_NEGOTIATED_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_PRIVATELY_NEGOTIATED_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PRIVATELY_NEGOTIATED_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_CUM_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_CUM_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_GUARANTEED_DELIVERY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_GUARANTEED_DELIVERY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_GUARANTEED_DELIVERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_GUARANTEED_DELIVERY));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_PROROGATION_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PROROGATION_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_PROROGATION_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PROROGATION_SELL));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_PRIOR_REFERENCE_PRICE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PRIOR_REFERENCE_PRICE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_PRIOR_REFERENCE_PRICE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PRIOR_REFERENCE_PRICE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_PORTFOLIO_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PORTFOLIO_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_PORTFOLIO_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PORTFOLIO_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_WORKED_PRINCIPAL_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_WORKED_PRINCIPAL_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_WORKED_PRINCIPAL_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_WORKED_PRINCIPAL_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_PORTFOLIO_TRANSFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PORTFOLIO_TRANSFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_PORTFOLIO_TRANSFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PORTFOLIO_TRANSFER));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_WEIGHTED_AVERAGE_PRICE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_WEIGHTED_AVERAGE_PRICE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_WEIGHTED_AVERAGE_PRICE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_WEIGHTED_AVERAGE_PRICE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_CUM_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_CUM_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_CUM_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_CUM_COUPON));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_T_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_T_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_T_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_T_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_BLOCK_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BLOCK_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_BLOCK_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_BLOCK_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_OTC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_OTC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_OTC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_OTC));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_AFTER_HOURS_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_AFTER_HOURS_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_AFTER_HOURS_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_AFTER_HOURS_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_DERIVATIVE_RELATED_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_DERIVATIVE_RELATED_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_DERIVATIVE_RELATED_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_DERIVATIVE_RELATED_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_REPURCHASE_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_REPURCHASE_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_REPURCHASE_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_REPURCHASE_AGREEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_SPECIAL_EX_RIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_SPECIAL_EX_RIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_SPECIAL_EX_RIGHTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_SPECIAL_EX_RIGHTS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_PROROGATION_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_PROROGATION_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_PROROGATION_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_PROROGATION_BUY));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_OPTION_CABINET_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_OPTION_CABINET_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_OPTION_CABINET_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_OPTION_CABINET_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdType_BUNCHED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdType_BUNCHED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdType_BUNCHED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdType_BUNCHED_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_RestructuringType_MODIFIED_MOD_RESTRUCTURING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RestructuringType_MODIFIED_MOD_RESTRUCTURING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RestructuringType_MODIFIED_MOD_RESTRUCTURING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RestructuringType_MODIFIED_MOD_RESTRUCTURING);
  return pyobj;
}


SWIGINTERN int Swig_var_RestructuringType_FULL_RESTRUCTURING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RestructuringType_FULL_RESTRUCTURING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RestructuringType_FULL_RESTRUCTURING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RestructuringType_FULL_RESTRUCTURING);
  return pyobj;
}


SWIGINTERN int Swig_var_RestructuringType_NO_RESTRUCTURING_SPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RestructuringType_NO_RESTRUCTURING_SPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RestructuringType_NO_RESTRUCTURING_SPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RestructuringType_NO_RESTRUCTURING_SPECIFIED);
  return pyobj;
}


SWIGINTERN int Swig_var_RestructuringType_MODIFIED_RESTRUCTURING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RestructuringType_MODIFIED_RESTRUCTURING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RestructuringType_MODIFIED_RESTRUCTURING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RestructuringType_MODIFIED_RESTRUCTURING);
  return pyobj;
}


SWIGINTERN int Swig_var_ProgRptReqs_REAL_TIME_EXECUTION_REPORTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProgRptReqs_REAL_TIME_EXECUTION_REPORTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProgRptReqs_REAL_TIME_EXECUTION_REPORTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_REAL_TIME_EXECUTION_REPORTS));
  return pyobj;
}


SWIGINTERN int Swig_var_ProgRptReqs_BUYSIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUSREQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProgRptReqs_BUYSIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUSREQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProgRptReqs_BUYSIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUSREQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_BUYSIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUSREQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_ProgRptReqs_SELL_SIDE_PERIODICALLY_SENDS_STATUS_USING_LIST_STATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProgRptReqs_SELL_SIDE_PERIODICALLY_SENDS_STATUS_USING_LIST_STATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProgRptReqs_SELL_SIDE_PERIODICALLY_SENDS_STATUS_USING_LIST_STATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_SELL_SIDE_PERIODICALLY_SENDS_STATUS_USING_LIST_STATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD));
  return pyobj;
}


SWIGINTERN int Swig_var_ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD));
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionID_EVENING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_EVENING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionID_EVENING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_EVENING);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionID_AFTER_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_AFTER_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionID_AFTER_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_AFTER_HOURS);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionID_HALFDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_HALFDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionID_HALFDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_HALFDAY);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionID_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionID_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionID_MORNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_MORNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionID_MORNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_MORNING);
  return pyobj;
}


SWIGINTERN int Swig_var_TradingSessionID_AFTERNOON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradingSessionID_AFTERNOON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradingSessionID_AFTERNOON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradingSessionID_AFTERNOON);
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_CANCELING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_CANCELING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_CANCELING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_CANCELING));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_ALL_DONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_ALL_DONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_ALL_DONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_ALL_DONE));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_IN_BIDDING_PROCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_IN_BIDDING_PROCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_IN_BIDDING_PROCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_IN_BIDDING_PROCESS));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_RECEIVED_FOR_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_RECEIVED_FOR_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_RECEIVED_FOR_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_RECEIVED_FOR_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_ALERT));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_RECEIVEDFOREXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_RECEIVEDFOREXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_RECEIVEDFOREXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_RECEIVEDFOREXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_INBIDDINGPROCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_INBIDDINGPROCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_INBIDDINGPROCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_INBIDDINGPROCESS));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_CANCELLING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_CANCELLING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_CANCELLING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_CANCELLING));
  return pyobj;
}


SWIGINTERN int Swig_var_ListOrderStatus_EXECUTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListOrderStatus_EXECUTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListOrderStatus_EXECUTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListOrderStatus_EXECUTING));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistStatus_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistStatus_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistStatus_REMINDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_REMINDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistStatus_REMINDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_REMINDER));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistStatus_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistStatus_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_HELD));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistStatus_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistStatus_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistStatus_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RegistStatus_ACCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingPriceDeterminationMethod_AVERAGE_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_AVERAGE_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingPriceDeterminationMethod_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingPriceDeterminationMethod_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingPriceDeterminationMethod_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingPriceDeterminationMethod_REGULAR));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ALL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ALL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ALL_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ALL_ORDERS));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT));
  return pyobj;
}


SWIGINTERN int Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejResponseTo_ORDER_CANCEL_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejResponseTo_ORDER_CANCEL_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejResponseTo_ORDER_CANCEL_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CxlRejResponseTo_ORDER_CANCEL_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_BY_QUOTETYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_BY_QUOTETYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_BY_QUOTETYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_BY_QUOTETYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_ALL_QUOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_ALL_QUOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_ALL_QUOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_ALL_QUOTES));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_FOR_ALL_QUOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_ALL_QUOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_FOR_ALL_QUOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_ALL_QUOTES));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_SECURITY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCancelType_CANCEL_FOR_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCancelType_CANCEL_FOR_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCancelType_CANCEL_FOR_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteCancelType_CANCEL_FOR_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_YIELD_TO_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_YIELD_TO_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_YIELD_TO_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_YIELD_TO_MATURITY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ALTERNATIVE_MINIMUM_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ALTERNATIVE_MINIMUM_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ALTERNATIVE_MINIMUM_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ALTERNATIVE_MINIMUM_TAX);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_VALUE_IN_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_VALUE_IN_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_VALUE_IN_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_VALUE_IN_PERCENT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_GEOGRAPHICS_AND_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_GEOGRAPHICS_AND_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_GEOGRAPHICS_AND_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_GEOGRAPHICS_AND_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_COUPON_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_COUPON_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_COUPON_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_COUPON_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_BANK_QUALIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BANK_QUALIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_BANK_QUALIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BANK_QUALIFIED);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_RATING_SOURCE_AND_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_RATING_SOURCE_AND_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_RATING_SOURCE_AND_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_RATING_SOURCE_AND_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_SUBSTITUTIONS_FREQUENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SUBSTITUTIONS_FREQUENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_SUBSTITUTIONS_FREQUENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTIONS_FREQUENCY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MINIMUM_DENOMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MINIMUM_DENOMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MINIMUM_DENOMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_DENOMINATION);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MAXIMUM_ORDER_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MAXIMUM_ORDER_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MAXIMUM_ORDER_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_ORDER_SIZE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ABSOLUTE_PREPAYMENT_SPEED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ABSOLUTE_PREPAYMENT_SPEED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ABSOLUTE_PREPAYMENT_SPEED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ABSOLUTE_PREPAYMENT_SPEED);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PRICING_FREQUENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRICING_FREQUENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PRICING_FREQUENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRICING_FREQUENCY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_CONSTANT_PREPAYMENT_YIELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CONSTANT_PREPAYMENT_YIELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_CONSTANT_PREPAYMENT_YIELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_YIELD);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_YIELD_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_YIELD_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_YIELD_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_YIELD_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_BENCHMARK_PRICE_SOURCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BENCHMARK_PRICE_SOURCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_BENCHMARK_PRICE_SOURCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BENCHMARK_PRICE_SOURCE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MAXIMUM_SUBSTITUTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MAXIMUM_SUBSTITUTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MAXIMUM_SUBSTITUTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_SUBSTITUTIONS);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MONTHLY_PREPAYMENT_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MONTHLY_PREPAYMENT_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MONTHLY_PREPAYMENT_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MONTHLY_PREPAYMENT_RATE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PURPOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PURPOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PURPOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PURPOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WHOLE_POOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WHOLE_POOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WHOLE_POOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WHOLE_POOL);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_LOAN_AGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LOAN_AGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_POOLS_MAXIMUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLS_MAXIMUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_POOLS_MAXIMUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLS_MAXIMUM);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MINIMUM_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MINIMUM_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MINIMUM_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_VALUATION_DISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_VALUATION_DISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_VALUATION_DISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_VALUATION_DISCOUNT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_GEOGRAPHICS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_GEOGRAPHICS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_GEOGRAPHICS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_GEOGRAPHICS);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_AMT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_AMT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_AMT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_AMT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WEIGHTED_AVERAGE_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WEIGHTED_AVERAGE_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_MATURITY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_CALL_PROTECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CALL_PROTECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_CALL_PROTECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CALL_PROTECTION);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_EXPLICIT_LOT_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_EXPLICIT_LOT_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_EXPLICIT_LOT_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_EXPLICIT_LOT_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_FREEFORM_TEXT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_FREEFORM_TEXT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_FREEFORM_TEXT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_FREEFORM_TEXT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_TRADE_VARIANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TRADE_VARIANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_TRADE_VARIANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TRADE_VARIANCE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WEIGHTED_AVERAGE_COUPONVALUE_IN_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_COUPONVALUE_IN_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WEIGHTED_AVERAGE_COUPONVALUE_IN_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_COUPONVALUE_IN_PERCENT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_STRUCTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_STRUCTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_STRUCTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_STRUCTURE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_RESTRICTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_RESTRICTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_RESTRICTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_RESTRICTED);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_CONSTANT_PREPAYMENT_PENALTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CONSTANT_PREPAYMENT_PENALTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_CONSTANT_PREPAYMENT_PENALTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_PENALTY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_TYPE_OF_REDEMPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TYPE_OF_REDEMPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_TYPE_OF_REDEMPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TYPE_OF_REDEMPTION);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_SECURITYTYPE_INCLUDED_OR_EXCLUDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SECURITYTYPE_INCLUDED_OR_EXCLUDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_SECURITYTYPE_INCLUDED_OR_EXCLUDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SECURITYTYPE_INCLUDED_OR_EXCLUDED);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PAYMENT_FREQUENCY_CALENDAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PAYMENT_FREQUENCY_CALENDAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PAYMENT_FREQUENCY_CALENDAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PAYMENT_FREQUENCY_CALENDAR);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ISSUERS_TICKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ISSUERS_TICKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ISSUERS_TICKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ISSUERS_TICKER);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MAXIMUM_LOAN_BALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MAXIMUM_LOAN_BALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MAXIMUM_LOAN_BALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MAXIMUM_LOAN_BALANCE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_BROKER_SALES_CREDIT_OVERRIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BROKER_SALES_CREDIT_OVERRIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_BROKER_SALES_CREDIT_OVERRIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BROKER_SALES_CREDIT_OVERRIDE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_OF_BMA_PREPAYMENT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_OF_BMA_PREPAYMENT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_OF_BMA_PREPAYMENT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_OF_BMA_PREPAYMENT_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ISO_CURRENCY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ISO_CURRENCY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ISO_CURRENCY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ISO_CURRENCY_CODE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MARKET_SECTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MARKET_SECTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MARKET_SECTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MARKET_SECTOR);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_POOL_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOL_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_POOL_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOL_IDENTIFIER);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_TYPE_OF_ROLL_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TYPE_OF_ROLL_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_TYPE_OF_ROLL_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TYPE_OF_ROLL_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_YEAR_OF_ISSUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_YEAR_OF_ISSUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_YEAR_OF_ISSUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_YEAR_OF_ISSUE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_LOOKBACK_DAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_LOOKBACK_DAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_LOOKBACK_DAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_LOOKBACK_DAYS);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_TYPE_OF_REDEMPTION_VALUES_ARE_NONCALLABLE_CALLABLE_PREFUNDED_ESCROWEDTOMATURITY_PUTABLE_CONVERTIBLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TYPE_OF_REDEMPTION_VALUES_ARE_NONCALLABLE_CALLABLE_PREFUNDED_ESCROWEDTOMATURITY_PUTABLE_CONVERTIBLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_TYPE_OF_REDEMPTION_VALUES_ARE_NONCALLABLE_CALLABLE_PREFUNDED_ESCROWEDTOMATURITY_PUTABLE_CONVERTIBLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TYPE_OF_REDEMPTION_VALUES_ARE_NONCALLABLE_CALLABLE_PREFUNDED_ESCROWEDTOMATURITY_PUTABLE_CONVERTIBLE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MATURITY_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MATURITY_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MATURITY_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MATURITY_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_CUSTOM_START_END_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CUSTOM_START_END_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_CUSTOM_START_END_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CUSTOM_START_END_DATE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ORDER_QUANTITY_INCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ORDER_QUANTITY_INCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ORDER_QUANTITY_INCREMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ORDER_QUANTITY_INCREMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_DISCOUNT_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_DISCOUNT_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_DISCOUNT_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_DISCOUNT_RATE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_CONSTANT_PREPAYMENT_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_CONSTANT_PREPAYMENT_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_CONSTANT_PREPAYMENT_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_CONSTANT_PREPAYMENT_RATE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_AVERAGE_LOAN_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_AVERAGE_LOAN_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_AVERAGE_LOAN_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_AVERAGE_LOAN_SIZE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_TRADERS_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_TRADERS_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_TRADERS_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_TRADERS_CREDIT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_POOLS_PER_LOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLS_PER_LOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_POOLS_PER_LOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_LOT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_LIFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LIFE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MATURITY_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MATURITY_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MATURITY_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MATURITY_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_POOLS_PER_MILLION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLS_PER_MILLION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_POOLS_PER_MILLION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_MILLION);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_LOT_VARIANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_LOT_VARIANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_LOT_VARIANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_LOT_VARIANCE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_AVERAGE_FICO_SCORE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_AVERAGE_FICO_SCORE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_AVERAGE_FICO_SCORE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_AVERAGE_FICO_SCORE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WEIGHTED_AVERAGE_MATURITY_VALUE_IN_MONTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_MATURITY_VALUE_IN_MONTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WEIGHTED_AVERAGE_MATURITY_VALUE_IN_MONTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_MATURITY_VALUE_IN_MONTHS);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PRICE_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRICE_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PRICE_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRICE_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MATURITY_YEAR_AND_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MATURITY_YEAR_AND_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MATURITY_YEAR_AND_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MATURITY_YEAR_AND_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_MINIMUM_INCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_MINIMUM_INCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_MINIMUM_INCREMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_MINIMUM_INCREMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WEIGHTED_AVERAGE_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WEIGHTED_AVERAGE_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_COUPON);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_SUBSTITUTIONS_LEFT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SUBSTITUTIONS_LEFT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_SUBSTITUTIONS_LEFT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SUBSTITUTIONS_LEFT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_NUMBER_OF_PIECES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_NUMBER_OF_PIECES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_NUMBER_OF_PIECES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_NUMBER_OF_PIECES);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_INSURED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_INSURED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_INSURED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_INSURED);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_BARGAIN_CONDITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BARGAIN_CONDITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_BARGAIN_CONDITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BARGAIN_CONDITIONS);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_POOLS_PER_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_POOLS_PER_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_POOLS_PER_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_POOLS_PER_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_VALUE_IN_MONTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_VALUE_IN_MONTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_VALUE_IN_MONTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_VALUE_IN_MONTHS);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_SINGLE_MONTHLY_MORTALITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_SINGLE_MONTHLY_MORTALITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_SINGLE_MONTHLY_MORTALITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_SINGLE_MONTHLY_MORTALITY);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_BROKERS_SALES_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BROKERS_SALES_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_BROKERS_SALES_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BROKERS_SALES_CREDIT);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_ISSUE_SIZE_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_ISSUE_SIZE_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_ISSUE_SIZE_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_ISSUE_SIZE_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_BARGAIN_CONDITIONS_SEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_BARGAIN_CONDITIONS_SEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_BARGAIN_CONDITIONS_SEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_BARGAIN_CONDITIONS_SEE);
  return pyobj;
}


SWIGINTERN int Swig_var_StipulationType_PRODUCTION_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StipulationType_PRODUCTION_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StipulationType_PRODUCTION_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::StipulationType_PRODUCTION_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_PriceQuoteMethod_PERCENT_OF_PAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQuoteMethod_PERCENT_OF_PAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceQuoteMethod_PERCENT_OF_PAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PriceQuoteMethod_PERCENT_OF_PAR);
  return pyobj;
}


SWIGINTERN int Swig_var_PriceQuoteMethod_STANDARD_MONEY_PER_UNIT_OF_A_PHYSICAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQuoteMethod_STANDARD_MONEY_PER_UNIT_OF_A_PHYSICAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceQuoteMethod_STANDARD_MONEY_PER_UNIT_OF_A_PHYSICAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PriceQuoteMethod_STANDARD_MONEY_PER_UNIT_OF_A_PHYSICAL);
  return pyobj;
}


SWIGINTERN int Swig_var_PriceQuoteMethod_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQuoteMethod_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceQuoteMethod_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PriceQuoteMethod_INDEX);
  return pyobj;
}


SWIGINTERN int Swig_var_PriceQuoteMethod_INTEREST_RATE_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceQuoteMethod_INTEREST_RATE_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceQuoteMethod_INTEREST_RATE_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PriceQuoteMethod_INTEREST_RATE_INDEX);
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_COMPID_PROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_COMPID_PROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_COMPID_PROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_COMPID_PROBLEM));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_SIGNATURE_PROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_SIGNATURE_PROBLEM));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_XML_VALIDATION_ERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_XML_VALIDATION_ERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_XML_VALIDATION_ERROR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_XML_VALIDATION_ERROR));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_UNDEFINED_TAG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_UNDEFINED_TAG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_UNDEFINED_TAG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_UNDEFINED_TAG));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_REQUIRED_TAG_MISSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_REQUIRED_TAG_MISSING));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_DECRYPTION_PROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_DECRYPTION_PROBLEM));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INVALID_TAG_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INVALID_TAG_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_VALUE_IS_INCORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_VALUE_IS_INCORRECT));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_INVALID_MSGTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_INVALID_MSGTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_INVALID_MSGTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_INVALID_MSGTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryType_TRI_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_TRI_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryType_TRI_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_TRI_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryType_HOLD_IN_CUSTODY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_HOLD_IN_CUSTODY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryType_HOLD_IN_CUSTODY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_HOLD_IN_CUSTODY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryType_FREE_DELIVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_FREE_DELIVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryType_FREE_DELIVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_FREE_DELIVER));
  return pyobj;
}


SWIGINTERN int Swig_var_DeliveryType_VERSUS_PAYMENT_DELIVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeliveryType_VERSUS_PAYMENT_DELIVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeliveryType_VERSUS_PAYMENT_DELIVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeliveryType_VERSUS_PAYMENT_DELIVER));
  return pyobj;
}


SWIGINTERN int Swig_var_Scope_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Scope_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Scope_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Scope_LOCAL));
  return pyobj;
}


SWIGINTERN int Swig_var_Scope_LOCAL_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Scope_LOCAL_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Scope_LOCAL_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Scope_LOCAL_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_Scope_GLOBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Scope_GLOBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Scope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Scope_GLOBAL));
  return pyobj;
}


SWIGINTERN int Swig_var_Scope_NATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Scope_NATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Scope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Scope_NATIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DeleteReason_CANCELLATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeleteReason_CANCELLATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeleteReason_CANCELLATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DeleteReason_CANCELLATION));
  return pyobj;
}


SWIGINTERN int Swig_var_DeleteReason_CANCELATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeleteReason_CANCELATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeleteReason_CANCELATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DeleteReason_CANCELATION));
  return pyobj;
}


SWIGINTERN int Swig_var_DeleteReason_ERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeleteReason_ERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeleteReason_ERROR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DeleteReason_ERROR));
  return pyobj;
}


SWIGINTERN int Swig_var_InViewOfCommon_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InViewOfCommon_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InViewOfCommon_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::InViewOfCommon_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_InViewOfCommon_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InViewOfCommon_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InViewOfCommon_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::InViewOfCommon_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_NoSides_ONE_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NoSides_ONE_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NoSides_ONE_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::NoSides_ONE_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_NoSides_BOTH_SIDES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NoSides_BOTH_SIDES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NoSides_BOTH_SIDES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::NoSides_BOTH_SIDES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_CERTIFICATE_OF_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_CERTIFICATE_OF_DEPOSIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MUNICIPAL_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MUNICIPAL_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MUNICIPAL_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MUNICIPAL_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MORTGAGE_INTEREST_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_INTEREST_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MORTGAGE_INTEREST_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_INTEREST_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MATURED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MATURED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MATURED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MATURED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FUTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FUTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FUTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FUTURE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TREASURY_BILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TREASURY_BILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TREASURY_BILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TREASURY_BILL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BILL_OF_EXCHANGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BILL_OF_EXCHANGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BILL_OF_EXCHANGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BILL_OF_EXCHANGES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TIME_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TIME_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TIME_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TIME_DEPOSIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MORTGAGE_IOETTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_IOETTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MORTGAGE_IOETTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_IOETTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REPURCHASE_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REPURCHASE_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REPURCHASE_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REPURCHASE_AGREEMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SPECIAL_OBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SPECIAL_OBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SPECIAL_OBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_OBLIGATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_COMMERCIAL_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COMMERCIAL_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_COMMERCIAL_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COMMERCIAL_PAPER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CORPORATE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CORPORATE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CORPORATE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CORPORATE_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CORP_MORTGAGE_BACKED_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CORP_MORTGAGE_BACKED_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CORP_MORTGAGE_BACKED_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CORP_MORTGAGE_BACKED_SECURITIES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_STRUCTURED_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_STRUCTURED_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_STRUCTURED_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_STRUCTURED_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REPURCHASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REPURCHASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REPURCHASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REPURCHASE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CANADIAN_MORTGAGE_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_MORTGAGE_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CANADIAN_MORTGAGE_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_MORTGAGE_BONDS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAX_REVENUE_ANTICIPATION_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAX_REVENUE_ANTICIPATION_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_TREASURY_BILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_BILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_TREASURY_BILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BILL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PLAZOS_FIJOS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PLAZOS_FIJOS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PLAZOS_FIJOS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PLAZOS_FIJOS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CANADIAN_TREASURY_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_TREASURY_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CANADIAN_TREASURY_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_TREASURY_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_YANKEE_CORPORATE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_YANKEE_CORPORATE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_YANKEE_CORPORATE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_YANKEE_CORPORATE_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BUY_SELLBACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BUY_SELLBACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BUY_SELLBACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BUY_SELLBACK);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_NO_ISITC_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_NO_ISITC_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_NO_ISITC_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_NO_ISITC_SECURITY_TYPE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PROMISSORY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PROMISSORY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PROMISSORY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PROMISSORY_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PRIVATE_EXPORT_FUNDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PRIVATE_EXPORT_FUNDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PRIVATE_EXPORT_FUNDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PRIVATE_EXPORT_FUNDING);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CASH);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_DEPOSIT_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DEPOSIT_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_DEPOSIT_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DEPOSIT_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FOREIGN_EXCHANGE_CONTRACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FOREIGN_EXCHANGE_CONTRACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FOREIGN_EXCHANGE_CONTRACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FOREIGN_EXCHANGE_CONTRACT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SECURITIES_PLEDGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SECURITIES_PLEDGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SECURITIES_PLEDGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SECURITIES_PLEDGE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_RETIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_RETIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_RETIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_RETIRED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OVERNIGHT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OVERNIGHT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OVERNIGHT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OVERNIGHT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REVENUE_ANTICIPATION_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVENUE_ANTICIPATION_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REVENUE_ANTICIPATION_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVENUE_ANTICIPATION_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REVERSE_REPURCHASE_AGREEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVERSE_REPURCHASE_AGREEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REVERSE_REPURCHASE_AGREEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVERSE_REPURCHASE_AGREEMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_WARRANT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_WARRANT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_WARRANT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_WARRANT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_LIQUIDITY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_LIQUIDITY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_LIQUIDITY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_LIQUIDITY_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MANDATORY_TENDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MANDATORY_TENDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MANDATORY_TENDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MANDATORY_TENDER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_COMMON_STOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COMMON_STOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_COMMON_STOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COMMON_STOCK);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_CORPORATE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_CORPORATE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_CORPORATE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_CORPORATE_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CALL_LOANS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CALL_LOANS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CALL_LOANS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CALL_LOANS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OPTIONS_ON_PHYSICAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OPTIONS_ON_PHYSICAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OPTIONS_ON_PHYSICAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_PHYSICAL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REVOLVER_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVOLVER_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REVOLVER_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVOLVER_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OPTION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FEDERAL_AGENCY_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_AGENCY_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FEDERAL_AGENCY_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_AGENCY_COUPON);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TAX_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAX_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TAX_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAX_ALLOCATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MISCELLANEOUS_PASS_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MISCELLANEOUS_PASS_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MISCELLANEOUS_PASS_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MISCELLANEOUS_PASS_THROUGH);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_VARIABLE_RATE_DEMAND_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_VARIABLE_RATE_DEMAND_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_VARIABLE_RATE_DEMAND_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_VARIABLE_RATE_DEMAND_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MORTGAGE_PRINCIPAL_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_PRINCIPAL_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MORTGAGE_PRINCIPAL_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_PRINCIPAL_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TAXABLE_MUNICIPAL_CP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAXABLE_MUNICIPAL_CP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TAXABLE_MUNICIPAL_CP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAXABLE_MUNICIPAL_CP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_INTEREST_RATE_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_INTEREST_RATE_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_INTEREST_RATE_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_INTEREST_RATE_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BANK_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BANK_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BANK_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BANK_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_ASSET_BACKED_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_ASSET_BACKED_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_ASSET_BACKED_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_ASSET_BACKED_SECURITIES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MULTILEG_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MULTILEG_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MULTILEG_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MULTILEG_INSTRUMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CREDIT_DEFAULT_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CREDIT_DEFAULT_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CREDIT_DEFAULT_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CREDIT_DEFAULT_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_USD_SUPRANATIONAL_COUPONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_USD_SUPRANATIONAL_COUPONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_USD_SUPRANATIONAL_COUPONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_USD_SUPRANATIONAL_COUPONS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REVOLVER_TERM_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVOLVER_TERM_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REVOLVER_TERM_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVOLVER_TERM_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MORTGAGE_PRINCIPLE_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_PRINCIPLE_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MORTGAGE_PRINCIPLE_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_PRINCIPLE_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REPLACED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REPLACED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REPLACED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REPLACED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_TREASURY_BILL_TBILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_BILL_TBILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_TREASURY_BILL_TBILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BILL_TBILL);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CERTIFICATE_OF_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CERTIFICATE_OF_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CERTIFICATE_OF_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_DEPOSIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SPECIAL_ASSESSMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SPECIAL_ASSESSMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SPECIAL_ASSESSMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_ASSESSMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SHORT_TERM_LOAN_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SHORT_TERM_LOAN_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SHORT_TERM_LOAN_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SHORT_TERM_LOAN_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_LETTER_OF_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_LETTER_OF_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_LETTER_OF_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_LETTER_OF_CREDIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OPTIONS_ON_COMBO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OPTIONS_ON_COMBO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OPTIONS_ON_COMBO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_COMBO);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SPECIAL_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SPECIAL_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SPECIAL_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SPECIAL_TAX);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PREFERRED_STOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PREFERRED_STOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PREFERRED_STOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PREFERRED_STOCK);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_TREASURY_NOTE_TNOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_NOTE_TNOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_TREASURY_NOTE_TNOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_NOTE_TNOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_AGENCY_POOLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_AGENCY_POOLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_AGENCY_POOLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_AGENCY_POOLS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MEDIUM_TERM_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MEDIUM_TERM_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MEDIUM_TERM_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MEDIUM_TERM_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CANADIAN_PROVINCIAL_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_PROVINCIAL_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CANADIAN_PROVINCIAL_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_PROVINCIAL_BONDS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_IOETTE_MORTGAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_IOETTE_MORTGAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_IOETTE_MORTGAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_IOETTE_MORTGAGE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SECURITIES_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SECURITIES_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SECURITIES_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SECURITIES_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CERTIFICATE_OF_PARTICIPATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CERTIFICATE_OF_PARTICIPATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CERTIFICATE_OF_PARTICIPATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_PARTICIPATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FEDERAL_HOME_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_HOME_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FEDERAL_HOME_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_HOME_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_CORPORATE_FLOATING_RATE_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_CORPORATE_FLOATING_RATE_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_CORPORATE_FLOATING_RATE_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_CORPORATE_FLOATING_RATE_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MULTI_LEG_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MULTI_LEG_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MULTI_LEG_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MULTI_LEG_INSTRUMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_WITHDRAWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_WITHDRAWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_WITHDRAWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_WITHDRAWN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MISCELLANEOUS_PASS_THRU_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MISCELLANEOUS_PASS_THRU is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MISCELLANEOUS_PASS_THRU_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MISCELLANEOUS_PASS_THRU);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CANADIAN_MONEY_MARKETS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_MONEY_MARKETS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CANADIAN_MONEY_MARKETS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_MONEY_MARKETS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FORWARD);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_SUPRANATIONAL_COUPONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_SUPRANATIONAL_COUPONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_SUPRANATIONAL_COUPONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_SUPRANATIONAL_COUPONS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_SOVEREIGNS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_SOVEREIGNS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_SOVEREIGNS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_SOVEREIGNS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CERTIFICATE_OF_OBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CERTIFICATE_OF_OBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CERTIFICATE_OF_OBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CERTIFICATE_OF_OBLIGATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BANK_DEPOSITORY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BANK_DEPOSITORY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BANK_DEPOSITORY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BANK_DEPOSITORY_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_TREASURY_BILL_USTB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_BILL_USTB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_TREASURY_BILL_USTB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BILL_USTB);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FX_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FX_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FX_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FX_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_WILDCARD_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_WILDCARD_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_WILDCARD_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_WILDCARD_ENTRY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SWING_LINE_FACILITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SWING_LINE_FACILITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SWING_LINE_FACILITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SWING_LINE_FACILITY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FEDERAL_HOUSING_AUTHORITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FEDERAL_HOUSING_AUTHORITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FEDERAL_HOUSING_AUTHORITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FEDERAL_HOUSING_AUTHORITY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CORPORATE_PRIVATE_PLACEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CORPORATE_PRIVATE_PLACEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CORPORATE_PRIVATE_PLACEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CORPORATE_PRIVATE_PLACEMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_GENERAL_OBLIGATION_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_GENERAL_OBLIGATION_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_GENERAL_OBLIGATION_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_GENERAL_OBLIGATION_BONDS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_INDEXED_LINKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_INDEXED_LINKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_INDEXED_LINKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_INDEXED_LINKED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TO_BE_ANNOUNCED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TO_BE_ANNOUNCED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TO_BE_ANNOUNCED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TO_BE_ANNOUNCED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_NON_DELIVERABLE_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_NON_DELIVERABLE_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_NON_DELIVERABLE_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_NON_DELIVERABLE_FORWARD);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OPTIONS_ON_FUTURES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OPTIONS_ON_FUTURES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OPTIONS_ON_FUTURES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OPTIONS_ON_FUTURES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TAX_ANTICIPATION_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAX_ANTICIPATION_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TAX_ANTICIPATION_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAX_ANTICIPATION_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TERM_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TERM_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TERM_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TERM_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_AMENDED_RESTATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_AMENDED_RESTATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_AMENDED_RESTATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_AMENDED_RESTATED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FX_FORWARD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FX_FORWARD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FX_FORWARD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FX_FORWARD);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CANADIAN_TREASURY_BILLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CANADIAN_TREASURY_BILLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CANADIAN_TREASURY_BILLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CANADIAN_TREASURY_BILLS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_DUAL_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DUAL_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_DUAL_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DUAL_CURRENCY);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MORTGAGE_PRIVATE_PLACEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_PRIVATE_PLACEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MORTGAGE_PRIVATE_PLACEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_PRIVATE_PLACEMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EURO_COMMERCIAL_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EURO_COMMERCIAL_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EURO_COMMERCIAL_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EURO_COMMERCIAL_PAPER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_TREASURY_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_TREASURY_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_SECURED_LIQUIDITY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_SECURED_LIQUIDITY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_SECURED_LIQUIDITY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_SECURED_LIQUIDITY_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MORTGAGE_BACKED_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MORTGAGE_BACKED_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MORTGAGE_BACKED_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MORTGAGE_BACKED_SECURITIES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_TREASURY_NOTE_UST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_NOTE_UST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_TREASURY_NOTE_UST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_NOTE_UST);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_DEBTOR_IN_POSSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DEBTOR_IN_POSSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_DEBTOR_IN_POSSESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DEBTOR_IN_POSSESSION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TERM_LIQUIDITY_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TERM_LIQUIDITY_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TERM_LIQUIDITY_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TERM_LIQUIDITY_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_US_TREASURY_NOTE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_US_TREASURY_NOTE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_US_TREASURY_NOTE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_US_TREASURY_NOTE_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_REVENUE_BONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_REVENUE_BONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_REVENUE_BONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_REVENUE_BONDS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BRIDGE_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BRIDGE_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BRIDGE_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BRIDGE_LOAN);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CATS_TIGERS_LIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CATS_TIGERS_LIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CATS_TIGERS_LIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CATS_TIGERS_LIONS);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BRADY_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BRADY_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BRADY_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BRADY_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_NO_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_NO_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_NO_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_NO_SECURITY_TYPE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_DEFAULTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_DEFAULTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_DEFAULTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_DEFAULTED);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_OTHER_ANTICIPATION_NOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_OTHER_ANTICIPATION_NOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_OTHER_ANTICIPATION_NOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_OTHER_ANTICIPATION_NOTES);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_MUTUAL_FUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_MUTUAL_FUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_MUTUAL_FUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_MUTUAL_FUND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_EXTENDED_COMM_NOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_EXTENDED_COMM_NOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_EXTENDED_COMM_NOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_EXTENDED_COMM_NOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_CONVERTIBLE_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_CONVERTIBLE_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_CONVERTIBLE_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_CONVERTIBLE_BOND);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_PFANDBRIEFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_PFANDBRIEFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_PFANDBRIEFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_PFANDBRIEFE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_FX_SPOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_FX_SPOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_FX_SPOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_FX_SPOT);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityType_BANKERS_ACCEPTANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityType_BANKERS_ACCEPTANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityType_BANKERS_ACCEPTANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityType_BANKERS_ACCEPTANCE);
  return pyobj;
}


SWIGINTERN int Swig_var_RoundingDirection_ROUND_DOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoundingDirection_ROUND_DOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoundingDirection_ROUND_DOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUND_DOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_RoundingDirection_ROUND_TO_NEAREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoundingDirection_ROUND_TO_NEAREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoundingDirection_ROUND_TO_NEAREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUND_TO_NEAREST));
  return pyobj;
}


SWIGINTERN int Swig_var_RoundingDirection_ROUND_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RoundingDirection_ROUND_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RoundingDirection_ROUND_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RoundingDirection_ROUND_UP));
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_MINUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_MINUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_MINUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_MINUTE);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_WEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_WEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_WEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_WEEK);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_SECOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_SECOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_SECOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_SECOND);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_MONTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_MONTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_MONTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_MONTH);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_HOUR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_HOUR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_HOUR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_HOUR);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_TimeUnit_YEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TimeUnit_YEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TimeUnit_YEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TimeUnit_YEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_LegSwapType_MODIFIED_DURATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegSwapType_MODIFIED_DURATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LegSwapType_MODIFIED_DURATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LegSwapType_MODIFIED_DURATION));
  return pyobj;
}


SWIGINTERN int Swig_var_LegSwapType_RISK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegSwapType_RISK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LegSwapType_RISK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LegSwapType_RISK));
  return pyobj;
}


SWIGINTERN int Swig_var_LegSwapType_PAR_FOR_PAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegSwapType_PAR_FOR_PAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LegSwapType_PAR_FOR_PAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LegSwapType_PAR_FOR_PAR));
  return pyobj;
}


SWIGINTERN int Swig_var_LegSwapType_PROCEEDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegSwapType_PROCEEDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LegSwapType_PROCEEDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LegSwapType_PROCEEDS));
  return pyobj;
}


SWIGINTERN int Swig_var_IOITransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOITransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOITransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOITransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_IOITransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOITransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOITransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOITransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_IOITransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOITransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOITransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOITransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqResult_VALID_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_VALID_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqResult_VALID_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_VALID_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqResult_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqResult_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstMode_DEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_DEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstMode_DEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_DEFAULT));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstMode_REQUEST_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_REQUEST_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstMode_REQUEST_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_REQUEST_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED));
  return pyobj;
}


SWIGINTERN int Swig_var_PreviouslyReported_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreviouslyReported_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PreviouslyReported_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PreviouslyReported_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_PreviouslyReported_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PreviouslyReported_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PreviouslyReported_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PreviouslyReported_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_PEGGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_PEGGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_PEGGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_PEGGED);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_MARKET_ON_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MARKET_ON_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_MARKET_ON_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_ON_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_SCALE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_FILL_OR_KILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_FILL_OR_KILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_FILL_OR_KILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_FILL_OR_KILL);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_ALL_OR_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_ALL_OR_NONE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_NOT_HELD);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_DIRECTED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_DIRECTED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_DIRECTED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_DIRECTED_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_STOP_STOCK_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_STOP_STOCK_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_STOP_STOCK_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_STOP_STOCK_TRANSACTION);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_OVER_THE_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_OVER_THE_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_OVER_THE_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_OVER_THE_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_ADD_ON_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_ADD_ON_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_ADD_ON_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_ADD_ON_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_MARKET_AT_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MARKET_AT_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_MARKET_AT_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_AT_CLOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_LIMIT_ON_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_LIMIT_ON_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_LIMIT_ON_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_LIMIT_ON_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_CASH_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_CASH_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_CASH_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_CASH_NOT_HELD);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_MARKET_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MARKET_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_MARKET_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_ON_CLOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_TIME_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_TIME_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_TIME_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_TIME_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_LIMIT_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_LIMIT_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_LIMIT_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_LIMIT_ON_CLOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_IMMEDIATE_OR_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_IMMEDIATE_OR_CANCEL);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_TRAILING_STOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_TRAILING_STOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_TRAILING_STOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_TRAILING_STOP);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_WORK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_WORK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_WORK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_WORK);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_RESERVE_SIZE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_RESERVE_SIZE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_RESERVE_SIZE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_RESERVE_SIZE_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_MINIMUM_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MINIMUM_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_MINIMUM_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MINIMUM_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_MARKET_AT_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_MARKET_AT_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_MARKET_AT_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_MARKET_AT_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_IMBALANCE_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_IMBALANCE_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_IMBALANCE_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_IMBALANCE_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityStatus_INACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_INACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityStatus_INACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_INACTIVE);
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityStatus_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityStatus_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityStatus_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SecurityStatus_ACTIVE);
  return pyobj;
}


SWIGINTERN int Swig_var_ProcessCode_SOFT_DOLLAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_SOFT_DOLLAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProcessCode_SOFT_DOLLAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_SOFT_DOLLAR));
  return pyobj;
}


SWIGINTERN int Swig_var_ProcessCode_PLAN_SPONSOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_PLAN_SPONSOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProcessCode_PLAN_SPONSOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_PLAN_SPONSOR));
  return pyobj;
}


SWIGINTERN int Swig_var_ProcessCode_STEP_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_STEP_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProcessCode_STEP_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEP_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_ProcessCode_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProcessCode_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_REGULAR));
  return pyobj;
}


SWIGINTERN int Swig_var_ProcessCode_SOFT_DOLLAR_STEP_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_SOFT_DOLLAR_STEP_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProcessCode_SOFT_DOLLAR_STEP_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_SOFT_DOLLAR_STEP_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_ProcessCode_STEP_OUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_STEP_OUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProcessCode_STEP_OUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_STEP_OUT));
  return pyobj;
}


SWIGINTERN int Swig_var_ProcessCode_SOFT_DOLLAR_STEP_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ProcessCode_SOFT_DOLLAR_STEP_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ProcessCode_SOFT_DOLLAR_STEP_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ProcessCode_SOFT_DOLLAR_STEP_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_TRY_TO_STOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRY_TO_STOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_TRY_TO_STOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRY_TO_STOP));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_PEG_TO_LIMIT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PEG_TO_LIMIT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_PEG_TO_LIMIT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PEG_TO_LIMIT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_EXECUTE_AS_DURATION_NEUTRAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_EXECUTE_AS_DURATION_NEUTRAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_EXECUTE_AS_DURATION_NEUTRAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXECUTE_AS_DURATION_NEUTRAL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_REINSTATE_ON_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_REINSTATE_ON_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_REINSTATE_ON_TRADING_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_REINSTATE_ON_TRADING_HALT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_NO_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NO_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_NO_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NO_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_PEGVWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PEGVWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_PEGVWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PEGVWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_STRICT_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STRICT_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_STRICT_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICT_SCALE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_AON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_AON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_AON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_AON));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_MARKPEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_MARKPEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_MARKPEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_MARKPEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_MIDPRCPEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_MIDPRCPEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_MIDPRCPEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_MIDPRCPEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_OKCROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OKCROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_OKCROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_OKCROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_TRAILING_STOP_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRAILING_STOP_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_TRAILING_STOP_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRAILING_STOP_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_EXECUTE_AS_FX_NEUTRAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_EXECUTE_AS_FX_NEUTRAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_EXECUTE_AS_FX_NEUTRAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXECUTE_AS_FX_NEUTRAL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CUSTDISPINST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CUSTDISPINST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CUSTDISPINST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CUSTDISPINST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_OK_TO_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OK_TO_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_OK_TO_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_OK_TO_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_SUSPEND_ON_SYSTEM_FAILURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_SUSPEND_ON_SYSTEM_FAILURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_SUSPEND_ON_SYSTEM_FAILURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_SUSPEND_ON_SYSTEM_FAILURE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_GO_ALONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_GO_ALONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_GO_ALONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_GO_ALONG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_INSTITONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_INSTITONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_INSTITONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_INSTITONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_DO_NOT_INCREASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_DO_NOT_INCREASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_DO_NOT_INCREASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_DO_NOT_INCREASE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_SUSPEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_SUSPEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_SUSPEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_SUSPEND));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_TRYTOSTOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRYTOSTOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_TRYTOSTOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRYTOSTOP));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_REINSTATE_ON_SYSTEM_FAILURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_REINSTATE_ON_SYSTEM_FAILURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_REINSTATE_ON_SYSTEM_FAILURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_REINSTATE_ON_SYSTEM_FAILURE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_SUSPEND_ON_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_SUSPEND_ON_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_SUSPEND_ON_TRADING_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_SUSPEND_ON_TRADING_HALT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_INTERMARKET_SWEEP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_INTERMARKET_SWEEP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_INTERMARKET_SWEEP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_INTERMARKET_SWEEP));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_BEST_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_BEST_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_BEST_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_BEST_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_PARTICIPATE_DONT_INITIATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PARTICIPATE_DONT_INITIATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_PARTICIPATE_DONT_INITIATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PARTICIPATE_DONT_INITIATE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_LASTPEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_LASTPEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_LASTPEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_LASTPEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_PEG_TO_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PEG_TO_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_PEG_TO_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PEG_TO_VWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_PRIMARY_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PRIMARY_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_PRIMARY_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PRIMARY_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_NONNEGO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NONNEGO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_NONNEGO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NONNEGO));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_IGNORE_PRICE_VALIDITY_CHECKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_IGNORE_PRICE_VALIDITY_CHECKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_IGNORE_PRICE_VALIDITY_CHECKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_IGNORE_PRICE_VALIDITY_CHECKS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_STAY_ON_BID_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STAY_ON_BID_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_STAY_ON_BID_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAY_ON_BID_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_NOTHELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NOTHELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_NOTHELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NOTHELD));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_STRICTSCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STRICTSCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_STRICTSCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICTSCALE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_REINSTATE_ON_CONNECTION_LOSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_REINSTATE_ON_CONNECTION_LOSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_REINSTATE_ON_CONNECTION_LOSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_REINSTATE_ON_CONNECTION_LOSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_DNI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_DNI is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_DNI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_DNI));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_TRYTOSCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRYTOSCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_TRYTOSCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRYTOSCALE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_PERCENT_OF_VOLUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PERCENT_OF_VOLUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_PERCENT_OF_VOLUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PERCENT_OF_VOLUME));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_GOALONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_GOALONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_GOALONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_GOALONG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_WORK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_WORK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_WORK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_WORK));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_HELD));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_NOCROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NOCROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_NOCROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NOCROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_RELEASE_FROM_SUSPENSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_RELEASE_FROM_SUSPENSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_RELEASE_FROM_SUSPENSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_RELEASE_FROM_SUSPENSION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_STRICT_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STRICT_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_STRICT_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STRICT_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_OPENPEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OPENPEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_OPENPEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_OPENPEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_STAY_ON_BIDSIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STAY_ON_BIDSIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_STAY_ON_BIDSIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAY_ON_BIDSIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_STAY_ON_OFFERSIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STAY_ON_OFFERSIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_STAY_ON_OFFERSIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAY_ON_OFFERSIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_OVER_THE_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OVER_THE_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_OVER_THE_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_OVER_THE_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_RESTATEONTRADINGHALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_RESTATEONTRADINGHALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_RESTATEONTRADINGHALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_RESTATEONTRADINGHALT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_INSTITUTIONS_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_INSTITUTIONS_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_INSTITUTIONS_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_INSTITUTIONS_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NOT_HELD));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CANCELONTRADINGHALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCELONTRADINGHALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CANCELONTRADINGHALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCELONTRADINGHALT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CANCELONSYSFAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCELONSYSFAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CANCELONSYSFAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCELONSYSFAIL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_MARKET_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_MARKET_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_MARKET_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_MARKET_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_TRADEALONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRADEALONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_TRADEALONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRADEALONG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CALL_FIRST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CALL_FIRST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CALL_FIRST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CALL_FIRST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CANCEL_ON_SYSTEM_FAILURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCEL_ON_SYSTEM_FAILURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CANCEL_ON_SYSTEM_FAILURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCEL_ON_SYSTEM_FAILURE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_NON_NEGOTIABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NON_NEGOTIABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_NON_NEGOTIABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NON_NEGOTIABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_TRY_TO_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRY_TO_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_TRY_TO_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRY_TO_SCALE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_EXTERNAL_ROUTING_ALLOWED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_EXTERNAL_ROUTING_ALLOWED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_EXTERNAL_ROUTING_ALLOWED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXTERNAL_ROUTING_ALLOWED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_STAY_ON_OFFER_SIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STAY_ON_OFFER_SIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_STAY_ON_OFFER_SIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAY_ON_OFFER_SIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CUSTOMER_DISPLAY_INSTRUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CUSTOMER_DISPLAY_INSTRUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CUSTOMER_DISPLAY_INSTRUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CUSTOMER_DISPLAY_INSTRUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_WORK_TO_TARGET_STRATEGY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_WORK_TO_TARGET_STRATEGY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_WORK_TO_TARGET_STRATEGY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_WORK_TO_TARGET_STRATEGY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_OVERDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OVERDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_OVERDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_OVERDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_LAST_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_LAST_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_LAST_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_LAST_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CALLFIRST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CALLFIRST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CALLFIRST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CALLFIRST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_REINSTATE_ON_SYSTEM_FAILUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_REINSTATE_ON_SYSTEM_FAILUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_REINSTATE_ON_SYSTEM_FAILUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_REINSTATE_ON_SYSTEM_FAILUE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_DO_NOT_REDUCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_DO_NOT_REDUCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_DO_NOT_REDUCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_DO_NOT_REDUCE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_MID_PRICE_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_MID_PRICE_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_MID_PRICE_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_MID_PRICE_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_ALL_OR_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_ALL_OR_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_OPENING_PEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_OPENING_PEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_OPENING_PEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_OPENING_PEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_PERCVOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PERCVOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_PERCVOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PERCVOL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_SUSPEND_ON_CONNECTION_LOSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_SUSPEND_ON_CONNECTION_LOSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_SUSPEND_ON_CONNECTION_LOSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_SUSPEND_ON_CONNECTION_LOSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CANCEL_ON_CONNECTION_LOSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCEL_ON_CONNECTION_LOSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CANCEL_ON_CONNECTION_LOSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCEL_ON_CONNECTION_LOSS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CANCEL_IF_NOT_BEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCEL_IF_NOT_BEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CANCEL_IF_NOT_BEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCEL_IF_NOT_BEST));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_PARTNOTINIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PARTNOTINIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_PARTNOTINIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PARTNOTINIT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_NETTING));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_IMBALANCE_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_IMBALANCE_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_IMBALANCE_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_IMBALANCE_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_DNR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_DNR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_DNR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_DNR));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_STAYOFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STAYOFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_STAYOFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAYOFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_STAYBID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_STAYBID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_STAYBID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_STAYBID));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_TRADE_ALONG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_TRADE_ALONG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_TRADE_ALONG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_TRADE_ALONG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_CANCEL_ON_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_CANCEL_ON_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_CANCEL_ON_TRADING_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_CANCEL_ON_TRADING_HALT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_RESTATEONSYSFAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_RESTATEONSYSFAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_RESTATEONSYSFAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_RESTATEONSYSFAIL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecInst_PRIMPEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecInst_PRIMPEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecInst_PRIMPEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecInst_PRIMPEG));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_CALCULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_CALCULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_CALCULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_CALCULATED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_PENDING_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PENDING_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_PENDING_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_TRADE_IN_A_CLEARING_HOLD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADE_IN_A_CLEARING_HOLD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_TRADE_IN_A_CLEARING_HOLD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_IN_A_CLEARING_HOLD));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_ORDER_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_ORDER_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_ORDER_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_ORDER_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_PENDING_CANCEL_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PENDING_CANCEL_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_PENDING_CANCEL_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_CANCEL_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_PARTIAL_FILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PARTIAL_FILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_PARTIAL_FILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PARTIAL_FILL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_PENDING_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PENDING_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_PENDING_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_STOPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_STOPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_STOPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_STOPPED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_CANCELED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_CANCELED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_CANCELED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_CANCELED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_PENDING_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_PENDING_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_PENDING_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_PENDING_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_TRADE_CORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADE_CORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_TRADE_CORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_CORRECT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_SUSPENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_SUSPENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_SUSPENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_SUSPENDED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_FILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_FILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_FILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_FILL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_RESTATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_RESTATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_RESTATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_RESTATED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_REPLACED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_REPLACED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_REPLACED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_REPLACED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_DONE_FOR_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_DONE_FOR_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_DONE_FOR_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_DONE_FOR_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_TRADE_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_TRADE_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_TRADE_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_TRADE_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecType_CANCELLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecType_CANCELLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecType_CANCELLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecType_CANCELLED));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegModel_USER_DEFINED_MULTLEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegModel_USER_DEFINED_MULTLEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegModel_USER_DEFINED_MULTLEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegModel_USER_DEFINED_MULTLEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegModel_PREDEFINED_MULTILEG_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegModel_PREDEFINED_MULTILEG_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegModel_PREDEFINED_MULTILEG_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegModel_PREDEFINED_MULTILEG_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_SWAP_NEXT_START_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_NEXT_START_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_SWAP_NEXT_START_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_NEXT_START_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_LAST_ELIGIBLE_TRADE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_LAST_ELIGIBLE_TRADE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_LAST_ELIGIBLE_TRADE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_LAST_ELIGIBLE_TRADE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_FIRST_DELIVERY_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_FIRST_DELIVERY_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_FIRST_DELIVERY_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_FIRST_DELIVERY_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_TENDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_TENDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_TENDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_TENDER));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_INITIAL_INVENTORY_DUE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_INITIAL_INVENTORY_DUE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_INITIAL_INVENTORY_DUE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_INITIAL_INVENTORY_DUE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_FIRST_INTENT_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_FIRST_INTENT_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_FIRST_INTENT_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_FIRST_INTENT_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_ACTIVATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_ACTIVATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_ACTIVATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_ACTIVATION));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_PUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_PUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_PUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_PUT));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_SWAP_START_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_START_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_SWAP_START_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_START_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_SWAP_NEXT_ROLL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_NEXT_ROLL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_SWAP_NEXT_ROLL_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_NEXT_ROLL_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_LAST_DELIVERY_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_LAST_DELIVERY_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_LAST_DELIVERY_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_LAST_DELIVERY_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_POSITION_REMOVAL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_POSITION_REMOVAL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_POSITION_REMOVAL_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_POSITION_REMOVAL_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_SWAP_ROLL_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_ROLL_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_SWAP_ROLL_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_ROLL_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_FINAL_INVENTORY_DUE_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_FINAL_INVENTORY_DUE_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_FINAL_INVENTORY_DUE_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_FINAL_INVENTORY_DUE_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_INACTIVIATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_INACTIVIATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_INACTIVIATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_INACTIVIATION));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_SWAP_END_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SWAP_END_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_SWAP_END_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_SWAP_END_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_LAST_INTENT_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_LAST_INTENT_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_LAST_INTENT_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_LAST_INTENT_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_SINKING_FUND_CALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_SINKING_FUND_CALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_SINKING_FUND_CALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_SINKING_FUND_CALL));
  return pyobj;
}


SWIGINTERN int Swig_var_EventType_CALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable EventType_CALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_EventType_CALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::EventType_CALL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocIndicator_ALLOCATION_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocIndicator_ALLOCATION_REQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_REQUIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeAllocIndicator_ALLOCATION_NOT_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeAllocIndicator_ALLOCATION_NOT_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeAllocIndicator_ALLOCATION_NOT_REQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeAllocIndicator_ALLOCATION_NOT_REQUIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_NOT_LOGGED_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_NOT_LOGGED_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_NOT_LOGGED_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_NOT_LOGGED_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_PASSWORD_INCORRECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_PASSWORD_INCORRECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_PASSWORD_INCORRECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_PASSWORD_INCORRECT));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_LOGGED_IN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_LOGGED_IN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_LOGGED_IN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_LOGGED_IN));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_USER_NOT_RECOGNISED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_USER_NOT_RECOGNISED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_USER_NOT_RECOGNISED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_USER_NOT_RECOGNISED));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_PASSWORD_CHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_PASSWORD_CHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_PASSWORD_CHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_PASSWORD_CHANGED));
  return pyobj;
}


SWIGINTERN int Swig_var_UserStatus_SESSION_SHUTDOWN_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UserStatus_SESSION_SHUTDOWN_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UserStatus_SESSION_SHUTDOWN_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UserStatus_SESSION_SHUTDOWN_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_WEEKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_WEEKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_WEEKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_WEEKS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_TENTHS_OF_A_SECOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_TENTHS_OF_A_SECOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_TENTHS_OF_A_SECOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_TENTHS_OF_A_SECOND));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_SECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_SECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_SECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_SECONDS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_MONTHS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_MONTHS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_MONTHS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MONTHS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_YEARS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_YEARS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_YEARS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_YEARS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_NANOSECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_NANOSECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_NANOSECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_NANOSECONDS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_HUNDREDTHS_OF_A_SECOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_HUNDREDTHS_OF_A_SECOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_HUNDREDTHS_OF_A_SECOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_HUNDREDTHS_OF_A_SECOND));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_HOURS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_MICROSECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_MICROSECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_MICROSECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MICROSECONDS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_MINUTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_MINUTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_MINUTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MINUTES));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_MILLISECONDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_MILLISECONDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_MILLISECONDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_MILLISECONDS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrderDelayUnit_DAYS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrderDelayUnit_DAYS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrderDelayUnit_DAYS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OrderDelayUnit_DAYS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradedFlatSwitch_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradedFlatSwitch_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradedFlatSwitch_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradedFlatSwitch_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_TradedFlatSwitch_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradedFlatSwitch_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradedFlatSwitch_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradedFlatSwitch_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_ACCEPTED_WITH_ERRORS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_ACCEPTED_WITH_ERRORS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_ACCEPTED_WITH_ERRORS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_ACCEPTED_WITH_ERRORS));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TrdRptStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TrdRptStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TrdRptStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TrdRptStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_PENDING_END_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_PENDING_END_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_PENDING_END_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_PENDING_END_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CROSS_MARKET_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CROSS_MARKET_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CROSS_MARKET_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CROSS_MARKET_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCELED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCELED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_LOCKED_MARKET_WARNING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_LOCKED_MARKET_WARNING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_LOCKED_MARKET_WARNING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_LOCKED_MARKET_WARNING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCELED_FOR_UNDERLYING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_FOR_UNDERLYING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCELED_FOR_UNDERLYING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_FOR_UNDERLYING));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_TOO_LATE_TO_END_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_TOO_LATE_TO_END is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_TOO_LATE_TO_END_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_TOO_LATE_TO_END));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCELED_FOR_SECURITY_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_FOR_SECURITY_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCELED_FOR_SECURITY_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_FOR_SECURITY_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCELED_ALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_ALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCELED_ALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_ALL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_PASS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_PASS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_PASS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_PASS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_QUERY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_QUERY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_QUERY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_QUERY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_EXPIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_EXPIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_EXPIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_EXPIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCELED_FOR_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCELED_FOR_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCELED_FOR_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCELED_FOR_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_REMOVED_FROM_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_REMOVED_FROM_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_REMOVED_FROM_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_REMOVED_FROM_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_ACTIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_CANCEL_FOR_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_CANCEL_FOR_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_CANCEL_FOR_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_CANCEL_FOR_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteStatus_QUOTE_NOT_FOUND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteStatus_QUOTE_NOT_FOUND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteStatus_QUOTE_NOT_FOUND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteStatus_QUOTE_NOT_FOUND));
  return pyobj;
}


SWIGINTERN int Swig_var_SolicitedFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SolicitedFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SolicitedFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SolicitedFlag_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_SolicitedFlag_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SolicitedFlag_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SolicitedFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SolicitedFlag_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_DEALER_SOLD_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_DEALER_SOLD_SHORT));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleReason_QUALIFED_SERVICE_REPRESENTATIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_QUALIFED_SERVICE_REPRESENTATIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleReason_QUALIFED_SERVICE_REPRESENTATIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_QUALIFED_SERVICE_REPRESENTATIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT));
  return pyobj;
}


SWIGINTERN int Swig_var_ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_PegRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK));
  return pyobj;
}


SWIGINTERN int Swig_var_PegRoundDirection_MORE_AGGRESSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegRoundDirection_MORE_AGGRESSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegRoundDirection_MORE_AGGRESSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MORE_AGGRESSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_PegRoundDirection_MORE_PASSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegRoundDirection_MORE_PASSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegRoundDirection_MORE_PASSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MORE_PASSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_PegRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PegRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PegRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PegRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK));
  return pyobj;
}


SWIGINTERN int Swig_var_ModelType_PROPRIETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ModelType_PROPRIETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ModelType_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ModelType_PROPRIETARY));
  return pyobj;
}


SWIGINTERN int Swig_var_ModelType_UTILITY_PROVIDED_STANDARD_MODEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ModelType_UTILITY_PROVIDED_STANDARD_MODEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ModelType_UTILITY_PROVIDED_STANDARD_MODEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ModelType_UTILITY_PROVIDED_STANDARD_MODEL));
  return pyobj;
}


SWIGINTERN int Swig_var_FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_FuturesValuationMethod_PREMIUM_STYLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FuturesValuationMethod_PREMIUM_STYLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FuturesValuationMethod_PREMIUM_STYLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FuturesValuationMethod_PREMIUM_STYLE);
  return pyobj;
}


SWIGINTERN int Swig_var_FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlMethod_CASH_SETTLEMENT_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlMethod_CASH_SETTLEMENT_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlMethod_CASH_SETTLEMENT_REQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlMethod_CASH_SETTLEMENT_REQUIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmStatus_CONFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_CONFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmStatus_CONFIRMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_CONFIRMED));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmStatus_REQUEST_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_REQUEST_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmStatus_REQUEST_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_REQUEST_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmStatus_MISMATCHED_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_MISMATCHED_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmStatus_MISMATCHED_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_MISMATCHED_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_LocateReqd_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LocateReqd_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LocateReqd_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LocateReqd_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_LocateReqd_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LocateReqd_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LocateReqd_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LocateReqd_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_Adjustment_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Adjustment_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Adjustment_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Adjustment_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_Adjustment_CORRECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Adjustment_CORRECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Adjustment_CORRECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Adjustment_CORRECTION));
  return pyobj;
}


SWIGINTERN int Swig_var_Adjustment_ERROR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Adjustment_ERROR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Adjustment_ERROR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Adjustment_ERROR));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnType_ASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnType_ASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnType_ASSIGNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_ASSIGNMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnType_TERMINATE_UNASSIGN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnType_TERMINATE_UNASSIGN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnType_TERMINATE_UNASSIGN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_TERMINATE_UNASSIGN));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnType_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnType_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnType_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnType_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_LastRptRequested_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastRptRequested_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastRptRequested_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastRptRequested_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_LastRptRequested_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastRptRequested_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastRptRequested_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastRptRequested_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSessID_END_OF_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSessID_END_OF_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSessID_END_OF_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlSessID_END_OF_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSessID_ELECTRONIC_TRADING_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSessID_ELECTRONIC_TRADING_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSessID_ELECTRONIC_TRADING_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlSessID_ELECTRONIC_TRADING_HOURS);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSessID_REGULAR_TRADING_HOURS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSessID_REGULAR_TRADING_HOURS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSessID_REGULAR_TRADING_HOURS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlSessID_REGULAR_TRADING_HOURS);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlSessID_INTRADAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlSessID_INTRADAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlSessID_INTRADAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlSessID_INTRADAY);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_LOCKED_IN_TRADE_BREAK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_LOCKED_IN_TRADE_BREAK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_LOCKED_IN_TRADE_BREAK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_LOCKED_IN_TRADE_BREAK));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_NO_WAS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_NO_WAS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_NO_WAS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_NO_WAS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ADDENDUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ADDENDUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ADDENDUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ADDENDUM));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_7_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_7 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_7_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_7));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_PENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_PENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_PENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_PENDED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_DEFAULTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_DEFAULTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_DEFAULTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_DEFAULTED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_DECLINE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_DECLINE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_DECLINE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_DECLINE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ALLEGED_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ALLEGED_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ALLEGED_TRADE_REPORT_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_TRADE_REPORT_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ALLEGED_TRADE_REPORT_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_TRADE_REPORT_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ALLEGED_15_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_15 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ALLEGED_15_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_15));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ALLEGED_ADDENDUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_ADDENDUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ALLEGED_ADDENDUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_ADDENDUM));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ALLEGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ALLEGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_SUBMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_SUBMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_SUBMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_SUBMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ALLEGED_1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ALLEGED_1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_1));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_INVALID_CMTA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_INVALID_CMTA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_INVALID_CMTA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_INVALID_CMTA));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ALLEGED_NO_WAS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ALLEGED_NO_WAS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ALLEGED_NO_WAS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ALLEGED_NO_WAS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_TRADE_REPORT_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_TRADE_REPORT_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_TRADE_REPORT_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_TRADE_REPORT_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeReportType_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeReportType_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeReportType_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradeReportType_ACCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseStyle_AMERICAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseStyle_AMERICAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseStyle_AMERICAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_AMERICAN));
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseStyle_EUROPEAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseStyle_EUROPEAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseStyle_EUROPEAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_EUROPEAN));
  return pyobj;
}


SWIGINTERN int Swig_var_ExerciseStyle_BERMUDA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExerciseStyle_BERMUDA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExerciseStyle_BERMUDA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ExerciseStyle_BERMUDA));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonChar_ADDITIONAL_INFORMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_ADDITIONAL_INFORMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonChar_ADDITIONAL_INFORMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ADDITIONAL_INFORMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonChar_NEW_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_NEW_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonChar_NEW_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEW_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonChar_NEWS_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_NEWS_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonChar_NEWS_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEWS_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonChar_ORDER_INFLUX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_ORDER_INFLUX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonChar_ORDER_INFLUX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ORDER_INFLUX));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonChar_NEWS_DISSEMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_NEWS_DISSEMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonChar_NEWS_DISSEMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_NEWS_DISSEMINATION));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonChar_EQUIPMENT_CHANGEOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_EQUIPMENT_CHANGEOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonChar_EQUIPMENT_CHANGEOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_EQUIPMENT_CHANGEOVER));
  return pyobj;
}


SWIGINTERN int Swig_var_HaltReasonChar_ORDER_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HaltReasonChar_ORDER_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HaltReasonChar_ORDER_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::HaltReasonChar_ORDER_IMBALANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestination_POSIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestination_POSIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestination_POSIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestination_POSIT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExDestination_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExDestination_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExDestination_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExDestination_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_WAREHOUSE_RECAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_WAREHOUSE_RECAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_WAREHOUSE_RECAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_WAREHOUSE_RECAP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_ACCEPT_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_ACCEPT_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_ACCEPT_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_ACCEPT_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_COMPLETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_COMPLETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_COMPLETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_COMPLETE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_REQUEST_TO_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_REQUEST_TO_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_REQUEST_TO_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REQUEST_TO_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_REVERSE_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_REVERSE_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_REVERSE_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_REVERSE_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocReportType_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocReportType_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocReportType_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocReportType_ACCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_INCOMPLETE_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_INCOMPLETE_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_INCOMPLETE_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_INCOMPLETE_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_REVERSAL_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_REVERSAL_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_REVERSAL_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_REVERSAL_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_CALCULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_CALCULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_CALCULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_CALCULATED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_ACCEPT_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_ACCEPT_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_ACCEPT_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_ACCEPT_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_BUYSIDE_CALCULATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_BUYSIDE_CALCULATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_BUYSIDE_CALCULATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_CALCULATED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_REQUEST_TO_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_REQUEST_TO_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_REQUEST_TO_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_REQUEST_TO_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_BUYSIDE_READY_TO_BOOK_5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_READY_TO_BOOK_5));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_6_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_BUYSIDE_READY_TO_BOOK_6 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_6_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_READY_TO_BOOK_6));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_COMPLETE_GROUP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_COMPLETE_GROUP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_COMPLETE_GROUP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_COMPLETE_GROUP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_BUYSIDE_READY_TO_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_READY_TO_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_READY_TO_BOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_READY_TO_BOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_READY_TO_BOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_READY_TO_BOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_WAREHOUSE_INSTRUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_WAREHOUSE_INSTRUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_WAREHOUSE_INSTRUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_WAREHOUSE_INSTRUCTION));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_BUYSIDE_PRELIMINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_BUYSIDE_PRELIMINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_BUYSIDE_PRELIMINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_BUYSIDE_PRELIMINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocType_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocType_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocType_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocType_ACCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_INSUFFICIENT_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_INSUFFICIENT_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_INSUFFICIENT_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_INSUFFICIENT_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_INVALID_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_INVALID_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_INVALID_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_INVALID_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_TOO_LATE_TO_ENTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_TOO_LATE_TO_ENTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_TOO_LATE_TO_ENTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_TOO_LATE_TO_ENTER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_EXCHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_EXCHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_EXCHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_EXCHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_PASS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_PASS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_PASS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_PASS));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_NO_INVENTORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_NO_INVENTORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_NO_INVENTORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_NO_INVENTORY));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_LiquidityIndType_20_DAY_MOVING_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_20_DAY_MOVING_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LiquidityIndType_20_DAY_MOVING_AVERAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_20_DAY_MOVING_AVERAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_LiquidityIndType_5_DAY_MOVING_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_5_DAY_MOVING_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LiquidityIndType_5_DAY_MOVING_AVERAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_5_DAY_MOVING_AVERAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_LiquidityIndType_5DAY_MOVING_AVERAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_5DAY_MOVING_AVERAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LiquidityIndType_5DAY_MOVING_AVERAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_5DAY_MOVING_AVERAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_LiquidityIndType_NORMAL_MARKET_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_NORMAL_MARKET_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LiquidityIndType_NORMAL_MARKET_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_NORMAL_MARKET_SIZE));
  return pyobj;
}


SWIGINTERN int Swig_var_LiquidityIndType_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LiquidityIndType_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LiquidityIndType_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::LiquidityIndType_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_StatusValue_IN_PROCESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_IN_PROCESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatusValue_IN_PROCESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_IN_PROCESS));
  return pyobj;
}


SWIGINTERN int Swig_var_StatusValue_NOT_CONNECTED_DOWN_EXPECTED_DOWN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_NOT_CONNECTED_DOWN_EXPECTED_DOWN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatusValue_NOT_CONNECTED_DOWN_EXPECTED_DOWN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_NOT_CONNECTED_DOWN_EXPECTED_DOWN));
  return pyobj;
}


SWIGINTERN int Swig_var_StatusValue_NOT_CONNECTED_2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_NOT_CONNECTED_2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatusValue_NOT_CONNECTED_2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_NOT_CONNECTED_2));
  return pyobj;
}


SWIGINTERN int Swig_var_StatusValue_NOT_CONNECTED_DOWN_EXPECTED_UP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_NOT_CONNECTED_DOWN_EXPECTED_UP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatusValue_NOT_CONNECTED_DOWN_EXPECTED_UP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_NOT_CONNECTED_DOWN_EXPECTED_UP));
  return pyobj;
}


SWIGINTERN int Swig_var_StatusValue_CONNECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_CONNECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatusValue_CONNECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_CONNECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_StatusValue_NOT_CONNECTED_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StatusValue_NOT_CONNECTED_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StatusValue_NOT_CONNECTED_3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StatusValue_NOT_CONNECTED_3));
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_EXCHANGE_FOR_PHYSICAL_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_EXCHANGE_FOR_PHYSICAL_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_EXCHANGE_FOR_PHYSICAL_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_EXCHANGE_FOR_PHYSICAL_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_TRANSFER_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSFER_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_TRANSFER_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSFER_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_INTER_SPREAD_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_INTER_SPREAD_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_INTER_SPREAD_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_INTER_SPREAD_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_INTRA_SPREAD_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_INTRA_SPREAD_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_INTRA_SPREAD_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_INTRA_SPREAD_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_START_OF_DAY_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_START_OF_DAY_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_START_OF_DAY_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_START_OF_DAY_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_DELIVERY_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_DELIVERY_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_DELIVERY_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_DELIVERY_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_PIT_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_PIT_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_PIT_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_PIT_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_TRANSACTION_FROM_ASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSACTION_FROM_ASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_TRANSACTION_FROM_ASSIGNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_FROM_ASSIGNMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_TRANSACTION_FROM_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSACTION_FROM_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_TRANSACTION_FROM_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_FROM_EXERCISE);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_OPTION_ASSIGNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_OPTION_ASSIGNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_OPTION_ASSIGNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_OPTION_ASSIGNMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_AS_OF_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_AS_OF_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_AS_OF_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_AS_OF_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_ELECTRONIC_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_ELECTRONIC_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_ELECTRONIC_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_ELECTRONIC_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_SUCCESSION_EVENT_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_SUCCESSION_EVENT_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_SUCCESSION_EVENT_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_SUCCESSION_EVENT_ADJUSTMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_OPTION_EXERCISE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_OPTION_EXERCISE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_OPTION_EXERCISE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_OPTION_EXERCISE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_TRANSACTION_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TRANSACTION_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_TRANSACTION_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TRANSACTION_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_NET_DELTA_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_NET_DELTA_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_NET_DELTA_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_NET_DELTA_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_DELIVERY_NOTICE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_DELIVERY_NOTICE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_DELIVERY_NOTICE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_DELIVERY_NOTICE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_TOTAL_TRANSACTION_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_TOTAL_TRANSACTION_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_TOTAL_TRANSACTION_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_TOTAL_TRANSACTION_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_ADJUSTMENT_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_ADJUSTMENT_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_ADJUSTMENT_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_ADJUSTMENT_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_END_OF_DAY_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_END_OF_DAY_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_END_OF_DAY_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_END_OF_DAY_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_RECEIVE_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_RECEIVE_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_RECEIVE_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_RECEIVE_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_CREDIT_EVENT_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_CREDIT_EVENT_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_CREDIT_EVENT_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_CREDIT_EVENT_ADJUSTMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_PRIVATELY_NEGOTIATED_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_PRIVATELY_NEGOTIATED_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_CORPORATE_ACTION_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_CORPORATE_ACTION_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_CORPORATE_ACTION_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_CORPORATE_ACTION_ADJUSTMENT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_CROSS_MARGIN_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_CROSS_MARGIN_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_CROSS_MARGIN_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_CROSS_MARGIN_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_INTEGRAL_SPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_INTEGRAL_SPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_INTEGRAL_SPLIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_INTEGRAL_SPLIT);
  return pyobj;
}


SWIGINTERN int Swig_var_PosType_ALLOCATION_TRADE_QTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosType_ALLOCATION_TRADE_QTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosType_ALLOCATION_TRADE_QTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PosType_ALLOCATION_TRADE_QTY);
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnAckType_ASSIGNMENT_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnAckType_ASSIGNMENT_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnAckType_ASSIGNMENT_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnAckType_ASSIGNMENT_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_StreamAsgnAckType_ASSIGNMENT_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StreamAsgnAckType_ASSIGNMENT_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StreamAsgnAckType_ASSIGNMENT_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::StreamAsgnAckType_ASSIGNMENT_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeBasis_ABSOLUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeBasis_ABSOLUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeBasis_ABSOLUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_ABSOLUTE));
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeBasis_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeBasis_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeBasis_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_MiscFeeBasis_PER_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MiscFeeBasis_PER_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MiscFeeBasis_PER_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MiscFeeBasis_PER_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FOREX_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FOREX_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FOREX_PREVIOUSLY_QUOTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_PREVIOUSLY_QUOTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FOREX_PREVIOUSLY_QUOTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_PREVIOUSLY_QUOTED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_PREVIOUS_FUND_VALUATION_POINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PREVIOUS_FUND_VALUATION_POINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_PREVIOUS_FUND_VALUATION_POINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUS_FUND_VALUATION_POINT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_PEGGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PEGGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_PEGGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_PEGGED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_LIMIT_WITH_OR_WITHOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMIT_WITH_OR_WITHOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_LIMIT_WITH_OR_WITHOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMIT_WITH_OR_WITHOUT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_STOP_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_STOP_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_STOP_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_STOP_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FOREX_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FOREX_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_SWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_PREVIOUSLY_QUOTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PREVIOUSLY_QUOTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_PREVIOUSLY_QUOTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSLY_QUOTED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_COUNTER_ORDER_SELECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_COUNTER_ORDER_SELECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_COUNTER_ORDER_SELECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_COUNTER_ORDER_SELECTION));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_MARKET_IF_TOUCHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKET_IF_TOUCHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_MARKET_IF_TOUCHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET_IF_TOUCHED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_NEXT_FUND_VALUATION_POINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_NEXT_FUND_VALUATION_POINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_NEXT_FUND_VALUATION_POINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_NEXT_FUND_VALUATION_POINT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FOREX_C_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_C is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FOREX_C_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_C));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_ON_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_STOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_STOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_STOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_STOP));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FOREX_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FOREX_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FOREX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FOREX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FUNARI_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FUNARI is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FUNARI_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FUNARI));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FOREX_F_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_F is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FOREX_F_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_F));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_PREVIOUSLY_INDICATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_PREVIOUSLY_INDICATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_PREVIOUSLY_INDICATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_PREVIOUSLY_INDICATED));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_WITH_OR_WITHOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_WITH_OR_WITHOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_WITH_OR_WITHOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_WITH_OR_WITHOUT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_MARKET_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKET_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_MARKET_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET_ON_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FOREX_G_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_G is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FOREX_G_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_G));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_LIMIT_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMIT_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_LIMIT_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMIT_ON_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_FOREX_H_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_FOREX_H is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_FOREX_H_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_FOREX_H));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_ON_BASIS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_ON_BASIS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_ON_BASIS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_ON_BASIS));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_LIMIT_OR_BETTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_LIMIT_OR_BETTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_LIMIT_OR_BETTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_LIMIT_OR_BETTER));
  return pyobj;
}


SWIGINTERN int Swig_var_OrdType_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OrdType_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OrdType_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OrdType_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_NON_ACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_NON_ACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_NON_ACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_NON_ACT);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_AUTO_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_AUTO_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_AUTO_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_AUTO_MATCH);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_CALL_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CALL_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_CALL_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CALL_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ACT_M2_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_M2_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ACT_M2_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_M2_MATCH);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ONE_PARTY_TRADE_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ONE_PARTY_TRADE_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ONE_PARTY_TRADE_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ONE_PARTY_TRADE_REPORT);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ACT_M1_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_M1_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ACT_M1_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_M1_MATCH);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_COUNTER_ORDER_SELECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_COUNTER_ORDER_SELECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_COUNTER_ORDER_SELECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_COUNTER_ORDER_SELECTION);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ISSUING_BUY_BACK_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ISSUING_BUY_BACK_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ISSUING_BUY_BACK_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ISSUING_BUY_BACK_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_CROSS_AUCTION_63_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CROSS_AUCTION_63 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_CROSS_AUCTION_63_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CROSS_AUCTION_63);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_CROSS_AUCTION_5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CROSS_AUCTION_5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_CROSS_AUCTION_5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CROSS_AUCTION_5);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_CALL_AUCTION_7_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CALL_AUCTION_7 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_CALL_AUCTION_7_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CALL_AUCTION_7);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_COUNTER_ORDER_SELECTION_64_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_COUNTER_ORDER_SELECTION_64 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_COUNTER_ORDER_SELECTION_64_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_COUNTER_ORDER_SELECTION_64);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_TWO_PARTY_TRADE_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_TWO_PARTY_TRADE_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_TWO_PARTY_TRADE_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_TWO_PARTY_TRADE_REPORT);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_AND_EXECUTION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_AND_EXECUTION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_AND_EXECUTION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_AND_EXECUTION_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ACT_DEFAULT_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_DEFAULT_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ACT_DEFAULT_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_DEFAULT_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ACT_ACCEPTED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_ACCEPTED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ACT_ACCEPTED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_ACCEPTED_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_COUNTER_ORDER_SELECTION_6_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_COUNTER_ORDER_SELECTION_6 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_COUNTER_ORDER_SELECTION_6_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_COUNTER_ORDER_SELECTION_6);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_AND_EXECUTION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_AND_EXECUTION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_AND_EXECUTION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_AND_EXECUTION_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADETYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADETYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADETYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADETYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_CROSS_AUCTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CROSS_AUCTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_CROSS_AUCTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CROSS_AUCTION);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_CALL_AUCTION_65_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CALL_AUCTION_65 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_CALL_AUCTION_65_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CALL_AUCTION_65);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_CONFIRMED_TRADE_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CONFIRMED_TRADE_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_CONFIRMED_TRADE_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CONFIRMED_TRADE_REPORT);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ACT_M6_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_M6_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ACT_M6_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_M6_MATCH);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_CONTINUOUS_AUTO_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_CONTINUOUS_AUTO_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_CONTINUOUS_AUTO_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_CONTINUOUS_AUTO_MATCH);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_OCS_LOCKED_IN_NON_ACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_OCS_LOCKED_IN_NON_ACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_OCS_LOCKED_IN_NON_ACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_OCS_LOCKED_IN_NON_ACT);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_MINUS_BADGES_AND_TIMES_ACT_M1_MATCH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_MINUS_BADGES_AND_TIMES_ACT_M1_MATCH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_MINUS_BADGES_AND_TIMES_ACT_M1_MATCH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_MINUS_BADGES_AND_TIMES_ACT_M1_MATCH);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2);
  return pyobj;
}


SWIGINTERN int Swig_var_MatchType_ACT_DEFAULT_AFTER_M2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchType_ACT_DEFAULT_AFTER_M2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchType_ACT_DEFAULT_AFTER_M2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MatchType_ACT_DEFAULT_AFTER_M2);
  return pyobj;
}


SWIGINTERN int Swig_var_OptPayoutType_BINARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_BINARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OptPayoutType_BINARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_BINARY));
  return pyobj;
}


SWIGINTERN int Swig_var_OptPayoutType_VANILLA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_VANILLA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OptPayoutType_VANILLA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_VANILLA));
  return pyobj;
}


SWIGINTERN int Swig_var_OptPayoutType_CAPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OptPayoutType_CAPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OptPayoutType_CAPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OptPayoutType_CAPPED));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketUpdateAction_DELETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketUpdateAction_DELETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketUpdateAction_DELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_DELETE));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketUpdateAction_ADD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketUpdateAction_ADD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketUpdateAction_ADD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_ADD));
  return pyobj;
}


SWIGINTERN int Swig_var_MarketUpdateAction_MODIFY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MarketUpdateAction_MODIFY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MarketUpdateAction_MODIFY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MarketUpdateAction_MODIFY));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRejectReason_UNKNOWN_DEAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_UNKNOWN_DEAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRejectReason_UNKNOWN_DEAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_UNKNOWN_DEAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAsgnRejectReason_INSUFFICIENT_COLLATERAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAsgnRejectReason_INSUFFICIENT_COLLATERAL));
  return pyobj;
}


SWIGINTERN int Swig_var_IndividualAllocType_SUB_ALLOCATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IndividualAllocType_SUB_ALLOCATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IndividualAllocType_SUB_ALLOCATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::IndividualAllocType_SUB_ALLOCATE));
  return pyobj;
}


SWIGINTERN int Swig_var_IndividualAllocType_THIRD_PARTY_ALLOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IndividualAllocType_THIRD_PARTY_ALLOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IndividualAllocType_THIRD_PARTY_ALLOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::IndividualAllocType_THIRD_PARTY_ALLOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE));
  return pyobj;
}


SWIGINTERN int Swig_var_GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES));
  return pyobj;
}


SWIGINTERN int Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE));
  return pyobj;
}


SWIGINTERN int Swig_var_GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES));
  return pyobj;
}


SWIGINTERN int Swig_var_PutOrCall_PUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PutOrCall_PUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PutOrCall_PUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PutOrCall_PUT));
  return pyobj;
}


SWIGINTERN int Swig_var_PutOrCall_CALL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PutOrCall_CALL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PutOrCall_CALL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PutOrCall_CALL));
  return pyobj;
}


SWIGINTERN int Swig_var_FundRenewWaiv_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FundRenewWaiv_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FundRenewWaiv_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FundRenewWaiv_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_FundRenewWaiv_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FundRenewWaiv_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FundRenewWaiv_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FundRenewWaiv_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_ForexReq_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ForexReq_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ForexReq_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ForexReq_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_ForexReq_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ForexReq_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ForexReq_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ForexReq_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_TickRuleType_TRADED_AS_A_SPREAD_LEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_TRADED_AS_A_SPREAD_LEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickRuleType_TRADED_AS_A_SPREAD_LEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_TRADED_AS_A_SPREAD_LEG));
  return pyobj;
}


SWIGINTERN int Swig_var_TickRuleType_REGULAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_REGULAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickRuleType_REGULAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_REGULAR));
  return pyobj;
}


SWIGINTERN int Swig_var_TickRuleType_VARIABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_VARIABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickRuleType_VARIABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_VARIABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_TickRuleType_SETTLED_AS_A_SPREAD_LEG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_SETTLED_AS_A_SPREAD_LEG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickRuleType_SETTLED_AS_A_SPREAD_LEG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_SETTLED_AS_A_SPREAD_LEG));
  return pyobj;
}


SWIGINTERN int Swig_var_TickRuleType_FIXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TickRuleType_FIXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TickRuleType_FIXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TickRuleType_FIXED));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionOffsetType_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionOffsetType_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionOffsetType_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionOffsetType_PRICE_TIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionOffsetType_PRICE_TIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionOffsetType_PRICE_TIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_PRICE_TIER));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionOffsetType_TICKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionOffsetType_TICKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionOffsetType_TICKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_TICKS));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionOffsetType_BASIS_POINTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionOffsetType_BASIS_POINTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionOffsetType_BASIS_POINTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionOffsetType_BASIS_POINTS));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_ConfirmTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ConfirmTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ConfirmTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ConfirmTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_MDSecSizeType_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDSecSizeType_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDSecSizeType_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MDSecSizeType_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesEvent_CHANGE_OF_TRADING_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesEvent_CHANGE_OF_TRADING_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesEvent_CHANGE_OF_TRADING_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesEvent_CHANGE_OF_TRADING_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesEvent_CHANGE_OF_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesEvent_CHANGE_OF_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesEvent_CHANGE_OF_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesEvent_CHANGE_OF_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesEvent_CHANGE_OF_TRADING_SUBSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesEvent_CHANGE_OF_TRADING_SUBSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesEvent_CHANGE_OF_TRADING_SUBSESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesEvent_CHANGE_OF_TRADING_SUBSESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesEvent_TRADING_RESUMES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesEvent_TRADING_RESUMES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesEvent_TRADING_RESUMES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesEvent_TRADING_RESUMES));
  return pyobj;
}


SWIGINTERN int Swig_var_DlvyInstType_SECURITIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DlvyInstType_SECURITIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DlvyInstType_SECURITIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DlvyInstType_SECURITIES));
  return pyobj;
}


SWIGINTERN int Swig_var_DlvyInstType_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DlvyInstType_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DlvyInstType_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DlvyInstType_CASH));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_IMPLIED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_IMPLIED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_IMPLIED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_IMPLIED_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OPENING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OPENING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENING_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_PRIOR_REFERENCE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_PRIOR_REFERENCE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_PRIOR_REFERENCE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_PRIOR_REFERENCE_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_LAST_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_LAST_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_LAST_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_LAST_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SELLER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SELLER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SELLER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SELLER);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_DISTRIBUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_DISTRIBUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_DISTRIBUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_DISTRIBUTION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_NEXT_DAY_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_NEXT_DAY_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_NEXT_DAY_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_NEXT_DAY_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_STRADDLE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STRADDLE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_STRADDLE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STRADDLE_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SPREAD);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CROSSED_AO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CROSSED_AO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CROSSED_AO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CROSSED_AO);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SOLD_LAST_SALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SOLD_LAST_SALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SOLD_LAST_SALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST_SALE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OPENED_SALE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENED_SALE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OPENED_SALE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENED_SALE_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_REOPEN_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_REOPEN_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_REOPEN_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_REOPEN_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SOLD_LAST_SALE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SOLD_LAST_SALE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SOLD_LAST_SALE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST_SALE_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_STOPPED_SOLD_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED_SOLD_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_STOPPED_SOLD_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_SOLD_LAST);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_FORM_T_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_FORM_T is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_FORM_T_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_FORM_T);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_ADJUSTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_ADJUSTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_ADJUSTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_ADJUSTED);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OUT_OF_SEQUENCE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OUT_OF_SEQUENCE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OUT_OF_SEQUENCE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OUT_OF_SEQUENCE_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_COMBO_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_COMBO_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_COMBO_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_COMBO_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_ONLY_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_ONLY_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_ONLY_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ONLY_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_STRADDLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STRADDLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_STRADDLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STRADDLE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OUTSIDE_SPREAD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OUTSIDE_SPREAD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OUTSIDE_SPREAD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OUTSIDE_SPREAD);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_BUNCHED_SALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BUNCHED_SALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_BUNCHED_SALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BUNCHED_SALE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_STOPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_STOPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_STOPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_STOPPED);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_LATE_OPEN_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_LATE_OPEN_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_LATE_OPEN_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_LATE_OPEN_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OPENING_REOPENING_TRADE_DETAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENING_REOPENING_TRADE_DETAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OPENING_REOPENING_TRADE_DETAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENING_REOPENING_TRADE_DETAIL);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_COMBO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_COMBO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_COMBO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_COMBO);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OPENING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OPENING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENING);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_ACQUISITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_ACQUISITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_ACQUISITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_ACQUISITION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OPENED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OPENED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OPENED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OPENED);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_NEXT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_NEXT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_NEXT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_NEXT_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_BARGAIN_CONDITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BARGAIN_CONDITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_BARGAIN_CONDITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BARGAIN_CONDITION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_STOPPED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_STOPPED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CONVERTED_PRICE_INDICATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CONVERTED_PRICE_INDICATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CONVERTED_PRICE_INDICATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CONVERTED_PRICE_INDICATOR);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OFFICIAL_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OFFICIAL_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OFFICIAL_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OFFICIAL_CLOSING_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_ADJUSTED_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_ADJUSTED_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_ADJUSTED_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_ADJUSTED_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_RULE_155_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_RULE_155_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_RULE_155_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_RULE_155_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_AUTOMATIC_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_AUTOMATIC_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_AUTOMATIC_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_AUTOMATIC_EXECUTION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CROSSED_X_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CROSSED_X is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CROSSED_X_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CROSSED_X);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_AUTO_EXECUTION_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_AUTO_EXECUTION_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_AUTO_EXECUTION_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_AUTO_EXECUTION_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_MULTILEG_TO_MULTILEG_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_MULTILEG_TO_MULTILEG_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_MULTILEG_TO_MULTILEG_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_MULTILEG_TO_MULTILEG_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_BASKET_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BASKET_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_BASKET_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BASKET_INDEX);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_FINAL_PRICE_OF_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_FINAL_PRICE_OF_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_FINAL_PRICE_OF_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_FINAL_PRICE_OF_SESSION);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_STOPPED_STOCK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED_STOCK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_STOPPED_STOCK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_STOCK);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_OFFICAL_CLOSING_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_OFFICAL_CLOSING_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_OFFICAL_CLOSING_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_OFFICAL_CLOSING_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CASH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_REGULAR_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_REGULAR_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_REGULAR_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_REGULAR_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_STOPPED_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_STOPPED_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_VOLUME_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_VOLUME_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_VOLUME_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_VOLUME_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_STOPPED_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_STOPPED_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_STOPPED_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_STOPPED_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_STOPPED_OUT_OF_SEQUENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_STOPPED_OUT_OF_SEQUENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_STOPPED_OUT_OF_SEQUENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_STOPPED_OUT_OF_SEQUENCE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CASH_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CASH_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CASH_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CASH_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SPLIT_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SPLIT_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SPLIT_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SPLIT_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_IMBALANCE_MORE_BUYERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_IMBALANCE_MORE_BUYERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_IMBALANCE_MORE_BUYERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_IMBALANCE_MORE_BUYERS);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_IMBALANCE_MORE_SELLERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_IMBALANCE_MORE_SELLERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_IMBALANCE_MORE_SELLERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_IMBALANCE_MORE_SELLERS);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_INTRADAY_TRADE_DETAIL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_INTRADAY_TRADE_DETAIL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_INTRADAY_TRADE_DETAIL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_INTRADAY_TRADE_DETAIL);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_RULE_127_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_RULE_127_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_RULE_127_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_RULE_127_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_BUNCHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BUNCHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_BUNCHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BUNCHED);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_REOPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_REOPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_REOPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_REOPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_EX_PIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_EX_PIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_EX_PIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_EX_PIT);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_DIRECT_PLUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_DIRECT_PLUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_DIRECT_PLUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_DIRECT_PLUS);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_LAST);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_AVERAGE_PRICE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_AVERAGE_PRICE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_AVERAGE_PRICE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_AVERAGE_PRICE_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SOLD_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SOLD_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SOLD_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SOLD_LAST);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_MARKETPLACE_ENTERED_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_MARKETPLACE_ENTERED_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_MARKETPLACE_ENTERED_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_MARKETPLACE_ENTERED_TRADE);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SPREAD_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SPREAD_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SPREAD_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SPREAD_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_CANCEL_OPEN_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_CANCEL_OPEN_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_CANCEL_OPEN_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_CANCEL_OPEN_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_EXCHANGE_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_EXCHANGE_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_EXCHANGE_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_EXCHANGE_LAST);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_FAST_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_FAST_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_FAST_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_FAST_MARKET);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_BURST_BASKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_BURST_BASKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_BURST_BASKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_BURST_BASKET);
  return pyobj;
}


SWIGINTERN int Swig_var_TradeCondition_SOLD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeCondition_SOLD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeCondition_SOLD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TradeCondition_SOLD);
  return pyobj;
}


SWIGINTERN int Swig_var_PriceLimitType_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceLimitType_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceLimitType_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceLimitType_TICKS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceLimitType_TICKS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceLimitType_TICKS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_TICKS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriceLimitType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriceLimitType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriceLimitType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriceLimitType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_PER_SHARE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PER_SHARE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_PER_SHARE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PER_SHARE));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_POINTS_PER_BOND_OR_CONTRACT_SUPPLY_CONTRACTMULTIPLIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_POINTS_PER_BOND_OR_CONTRACT_SUPPLY_CONTRACTMULTIPLIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_POINTS_PER_BOND_OR_CONTRACT_SUPPLY_CONTRACTMULTIPLIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_POINTS_PER_BOND_OR_CONTRACT_SUPPLY_CONTRACTMULTIPLIER));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_ABSOLUTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_ABSOLUTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_ABSOLUTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_ABSOLUTE));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_PER_BOND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PER_BOND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_PER_BOND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PER_BOND));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_PERCENTAGE_WAIVED_4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PERCENTAGE_WAIVED_4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_PERCENTAGE_WAIVED_4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENTAGE_WAIVED_4));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_POINTS_PER_BOND_OR_CONTRACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_POINTS_PER_BOND_OR_CONTRACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_POINTS_PER_BOND_OR_CONTRACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_POINTS_PER_BOND_OR_CONTRACT));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_PERCENTAGE_WAIVED_5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PERCENTAGE_WAIVED_5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_PERCENTAGE_WAIVED_5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENTAGE_WAIVED_5));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_PER_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PER_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_PER_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PER_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_PERCENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_PERCENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_PERCENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_PERCENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_4));
  return pyobj;
}


SWIGINTERN int Swig_var_CommType_5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CommType_5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CommType_5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CommType_5));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS));
  return pyobj;
}


SWIGINTERN int Swig_var_FinancialStatus_BANKRUPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FinancialStatus_BANKRUPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FinancialStatus_BANKRUPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_BANKRUPT));
  return pyobj;
}


SWIGINTERN int Swig_var_FinancialStatus_RESTRICTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FinancialStatus_RESTRICTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FinancialStatus_RESTRICTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_RESTRICTED));
  return pyobj;
}


SWIGINTERN int Swig_var_FinancialStatus_PENDING_DELISTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FinancialStatus_PENDING_DELISTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FinancialStatus_PENDING_DELISTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::FinancialStatus_PENDING_DELISTING));
  return pyobj;
}


SWIGINTERN int Swig_var_LastFragment_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastFragment_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastFragment_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastFragment_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_LastFragment_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastFragment_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastFragment_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastFragment_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_NotifyBrokerOfCredit_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NotifyBrokerOfCredit_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NotifyBrokerOfCredit_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::NotifyBrokerOfCredit_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_NotifyBrokerOfCredit_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NotifyBrokerOfCredit_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NotifyBrokerOfCredit_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::NotifyBrokerOfCredit_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_DEPARTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_DEPARTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_DEPARTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_DEPARTMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_FAX_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FAX_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_FAX_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FAX_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_CASH_ACCOUNT_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CASH_ACCOUNT_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_CASH_ACCOUNT_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CASH_ACCOUNT_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_REGISTERED_ADDRESS_12_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTERED_ADDRESS_12 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_REGISTERED_ADDRESS_12_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTERED_ADDRESS_12));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_CONTACT_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CONTACT_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_CONTACT_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CONTACT_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_PERSON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PERSON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_PERSON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PERSON));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SECURITY_LOCATE_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SECURITY_LOCATE_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SECURITY_LOCATE_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SECURITY_LOCATE_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_POSITION_ACCOUNT_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_POSITION_ACCOUNT_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_POSITION_ACCOUNT_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_POSITION_ACCOUNT_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_CASH_ACCOUNT_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CASH_ACCOUNT_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_CASH_ACCOUNT_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CASH_ACCOUNT_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_POSTAL_ADDRESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_POSTAL_ADDRESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_POSTAL_ADDRESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_POSTAL_ADDRESS));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_PROFESSIONAL_CLIENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PROFESSIONAL_CLIENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_PROFESSIONAL_CLIENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PROFESSIONAL_CLIENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_LOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_LOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_LOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_FUND_ACCOUNT_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FUND_ACCOUNT_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_FUND_ACCOUNT_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FUND_ACCOUNT_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_REGISTRATION_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTRATION_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_REGISTRATION_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTRATION_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SYSTEM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SYSTEM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SYSTEM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SYSTEM));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_REGULATORY_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGULATORY_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_REGULATORY_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGULATORY_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_TELEX_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_TELEX_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_TELEX_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_TELEX_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_REGISTERED_ADDRESS_18_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTERED_ADDRESS_18 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_REGISTERED_ADDRESS_18_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTERED_ADDRESS_18));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_BIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_BIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_BIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_BIC));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_REGISTRATION_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_REGISTRATION_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_REGISTRATION_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_REGISTRATION_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_EMAIL_ADDRESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_EMAIL_ADDRESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_EMAIL_ADDRESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_EMAIL_ADDRESS));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_LOCATION_DESK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_LOCATION_DESK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_LOCATION_DESK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_LOCATION_DESK));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_APPLICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_APPLICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_APPLICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_APPLICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SECURITIES_ACCOUNT_NAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SECURITIES_ACCOUNT_NAME));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_PHONE_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_PHONE_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_PHONE_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_PHONE_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_ELIGIBLE_COUNTERPARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_ELIGIBLE_COUNTERPARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_ELIGIBLE_COUNTERPARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_ELIGIBLE_COUNTERPARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_EXECUTION_VENUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_EXECUTION_VENUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_EXECUTION_VENUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_EXECUTION_VENUE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_SECURITIES_ACCOUNT_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_SECURITIES_ACCOUNT_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartySubIDType_FULL_LEGAL_NAME_OF_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartySubIDType_FULL_LEGAL_NAME_OF_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartySubIDType_FULL_LEGAL_NAME_OF_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PartySubIDType_FULL_LEGAL_NAME_OF_FIRM));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocNoOrdersType_EXPLICIT_LIST_PROVIDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocNoOrdersType_EXPLICIT_LIST_PROVIDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocNoOrdersType_EXPLICIT_LIST_PROVIDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocNoOrdersType_EXPLICIT_LIST_PROVIDED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocNoOrdersType_NOT_SPECIFIED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocNoOrdersType_NOT_SPECIFIED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocNoOrdersType_NOT_SPECIFIED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocNoOrdersType_NOT_SPECIFIED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocLinkType_FX_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocLinkType_FX_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocLinkType_FX_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_FX_SWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocLinkType_F_X_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocLinkType_F_X_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocLinkType_F_X_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_F_X_NETTING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocLinkType_FX_NETTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocLinkType_FX_NETTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocLinkType_FX_NETTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_FX_NETTING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocLinkType_F_X_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocLinkType_F_X_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocLinkType_F_X_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocLinkType_F_X_SWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingSettlementType_T_PLUS_1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingSettlementType_T_PLUS_1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingSettlementType_T_PLUS_1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingSettlementType_T_PLUS_1));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingSettlementType_T_PLUS_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingSettlementType_T_PLUS_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingSettlementType_T_PLUS_3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingSettlementType_T_PLUS_3));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingSettlementType_T_PLUS_4_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingSettlementType_T_PLUS_4 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingSettlementType_T_PLUS_4_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::UnderlyingSettlementType_T_PLUS_4));
  return pyobj;
}


SWIGINTERN int Swig_var_DisplayMethod_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayMethod_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisplayMethod_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_DisplayMethod_UNDISCLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayMethod_UNDISCLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisplayMethod_UNDISCLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_UNDISCLOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_DisplayMethod_RANDOM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayMethod_RANDOM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisplayMethod_RANDOM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_RANDOM));
  return pyobj;
}


SWIGINTERN int Swig_var_DisplayMethod_INITIAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DisplayMethod_INITIAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DisplayMethod_INITIAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DisplayMethod_INITIAL));
  return pyobj;
}


SWIGINTERN int Swig_var_CollStatus_PARTIALLY_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_PARTIALLY_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollStatus_PARTIALLY_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_PARTIALLY_ASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollStatus_ASSIGNMENT_PROPOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_ASSIGNMENT_PROPOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollStatus_ASSIGNMENT_PROPOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_ASSIGNMENT_PROPOSED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollStatus_CHALLENGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_CHALLENGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollStatus_CHALLENGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_CHALLENGED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollStatus_ASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_ASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollStatus_ASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_ASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollStatus_UNASSIGNED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollStatus_UNASSIGNED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollStatus_UNASSIGNED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollStatus_UNASSIGNED));
  return pyobj;
}


SWIGINTERN int Swig_var_SideValueInd_SIDEVALUE_2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideValueInd_SIDEVALUE_2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideValueInd_SIDEVALUE_2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDEVALUE_2));
  return pyobj;
}


SWIGINTERN int Swig_var_SideValueInd_SIDEVALUE1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideValueInd_SIDEVALUE1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideValueInd_SIDEVALUE1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDEVALUE1));
  return pyobj;
}


SWIGINTERN int Swig_var_SideValueInd_SIDE_VALUE_1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideValueInd_SIDE_VALUE_1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideValueInd_SIDE_VALUE_1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDE_VALUE_1));
  return pyobj;
}


SWIGINTERN int Swig_var_SideValueInd_SIDE_VALUE_2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SideValueInd_SIDE_VALUE_2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SideValueInd_SIDE_VALUE_2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SideValueInd_SIDE_VALUE_2));
  return pyobj;
}


SWIGINTERN int Swig_var_MsgDirection_RECEIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgDirection_RECEIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgDirection_RECEIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MsgDirection_RECEIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_MsgDirection_SEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MsgDirection_SEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MsgDirection_SEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MsgDirection_SEND));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateAction_DELETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_DELETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateAction_DELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateAction_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateAction_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateAction_DELETE_THRU_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_DELETE_THRU is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateAction_DELETE_THRU_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE_THRU));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateAction_DELETE_FROM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_DELETE_FROM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateAction_DELETE_FROM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_DELETE_FROM));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateAction_OVERLAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_OVERLAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateAction_OVERLAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_OVERLAY));
  return pyobj;
}


SWIGINTERN int Swig_var_MDUpdateAction_CHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDUpdateAction_CHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDUpdateAction_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDUpdateAction_CHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchStatus_COMPARED_MATCHED_OR_AFFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_COMPARED_MATCHED_OR_AFFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchStatus_COMPARED_MATCHED_OR_AFFIRMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MatchStatus_COMPARED_MATCHED_OR_AFFIRMED));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchStatus_ADVISORY_OR_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_ADVISORY_OR_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchStatus_ADVISORY_OR_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MatchStatus_ADVISORY_OR_ALERT));
  return pyobj;
}


SWIGINTERN int Swig_var_MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED));
  return pyobj;
}


SWIGINTERN int Swig_var_RateSource_REUTERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSource_REUTERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RateSource_REUTERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSource_REUTERS));
  return pyobj;
}


SWIGINTERN int Swig_var_RateSource_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSource_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RateSource_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSource_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_RateSource_BLOOMBERG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSource_BLOOMBERG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RateSource_BLOOMBERG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSource_BLOOMBERG));
  return pyobj;
}


SWIGINTERN int Swig_var_RateSource_TELERATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RateSource_TELERATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RateSource_TELERATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RateSource_TELERATE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocPositionEffect_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocPositionEffect_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocPositionEffect_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocPositionEffect_FIFO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocPositionEffect_FIFO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocPositionEffect_FIFO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_FIFO));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocPositionEffect_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocPositionEffect_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocPositionEffect_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocPositionEffect_ROLLED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocPositionEffect_ROLLED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocPositionEffect_ROLLED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AllocPositionEffect_ROLLED));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_PROPRIETARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_PROPRIETARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_PROPRIETARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_PROPRIETARY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_TAIWANESE_TRADING_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_TAIWANESE_TRADING_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_TAIWANESE_TRADING_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAIWANESE_TRADING_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_TAIWANESE_TRADING_ACCT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_TAIWANESE_TRADING_ACCT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_TAIWANESE_TRADING_ACCT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAIWANESE_TRADING_ACCT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_US_SOCIAL_SECURITY_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_US_SOCIAL_SECURITY_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_US_SOCIAL_SECURITY_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_US_SOCIAL_SECURITY_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_DIRECTED_BROKER_THREE_CHARACTER_ACRONYM_AS_DEFINED_IN_ISITC_ETC_BEST_PRACTICE_GUIDELINES_DOCUMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_DIRECTED_BROKER_THREE_CHARACTER_ACRONYM_AS_DEFINED_IN_ISITC_ETC_BEST_PRACTICE_GUIDELINES_DOCUMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_DIRECTED_BROKER_THREE_CHARACTER_ACRONYM_AS_DEFINED_IN_ISITC_ETC_BEST_PRACTICE_GUIDELINES_DOCUMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_DIRECTED_BROKER_THREE_CHARACTER_ACRONYM_AS_DEFINED_IN_ISITC_ETC_BEST_PRACTICE_GUIDELINES_DOCUMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_SETTLEMENT_ENTITY_LOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_SETTLEMENT_ENTITY_LOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_SETTLEMENT_ENTITY_LOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_SETTLEMENT_ENTITY_LOCATION));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_PROPRIETARY_CUSTOM_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_PROPRIETARY_CUSTOM_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_PROPRIETARY_CUSTOM_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_PROPRIETARY_CUSTOM_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_BIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_BIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_BIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_BIC));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_CHINESE_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_CHINESE_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_CHINESE_INVESTOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_CHINESE_INVESTOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_MIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_MIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_MIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_MIC));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_KOREAN_INVESTOR_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_KOREAN_INVESTOR_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_KOREAN_INVESTOR_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_KOREAN_INVESTOR_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_ISO_COUNTRY_CODE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_ISO_COUNTRY_CODE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_ISO_COUNTRY_CODE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_ISO_COUNTRY_CODE));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID));
  return pyobj;
}


SWIGINTERN int Swig_var_PartyIDSource_CHINESE_B_SHARE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PartyIDSource_CHINESE_B_SHARE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PartyIDSource_CHINESE_B_SHARE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PartyIDSource_CHINESE_B_SHARE));
  return pyobj;
}


SWIGINTERN int Swig_var_ExchangeForPhysical_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExchangeForPhysical_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExchangeForPhysical_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExchangeForPhysical_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_ExchangeForPhysical_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExchangeForPhysical_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExchangeForPhysical_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExchangeForPhysical_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_TRADING_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_TRADING_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_CHANGE_OF_BOOK_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_BOOK_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_CHANGE_OF_BOOK_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_BOOK_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_TRADING_RESUMES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_TRADING_RESUMES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_TRADING_RESUMES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_TRADING_RESUMES));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAction_ADD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAction_ADD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAction_ADD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAction_ADD));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAction_REMOVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAction_REMOVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAction_REMOVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAction_REMOVE));
  return pyobj;
}


SWIGINTERN int Swig_var_CollAction_RETAIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CollAction_RETAIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CollAction_RETAIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CollAction_RETAIN));
  return pyobj;
}


SWIGINTERN int Swig_var_PossDupFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PossDupFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PossDupFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PossDupFlag_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_PossDupFlag_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PossDupFlag_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PossDupFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::PossDupFlag_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_ListStatusType_ALL_DONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_ALL_DONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListStatusType_ALL_DONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ALL_DONE));
  return pyobj;
}


SWIGINTERN int Swig_var_ListStatusType_TIMED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_TIMED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListStatusType_TIMED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_TIMED));
  return pyobj;
}


SWIGINTERN int Swig_var_ListStatusType_EXECSTARTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_EXECSTARTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListStatusType_EXECSTARTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_EXECSTARTED));
  return pyobj;
}


SWIGINTERN int Swig_var_ListStatusType_RESPONSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_RESPONSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListStatusType_RESPONSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_RESPONSE));
  return pyobj;
}


SWIGINTERN int Swig_var_ListStatusType_ALLDONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_ALLDONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListStatusType_ALLDONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ALLDONE));
  return pyobj;
}


SWIGINTERN int Swig_var_ListStatusType_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListStatusType_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ALERT));
  return pyobj;
}


SWIGINTERN int Swig_var_ListStatusType_ACK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_ACK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListStatusType_ACK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_ACK));
  return pyobj;
}


SWIGINTERN int Swig_var_ListStatusType_EXEC_STARTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ListStatusType_EXEC_STARTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ListStatusType_EXEC_STARTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ListStatusType_EXEC_STARTED));
  return pyobj;
}


SWIGINTERN int Swig_var_GapFillFlag_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GapFillFlag_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GapFillFlag_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::GapFillFlag_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_GapFillFlag_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GapFillFlag_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GapFillFlag_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::GapFillFlag_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_TWO_PARTY_REPORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_TWO_PARTY_REPORT));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_TRADE_CONFIRMATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_TRADE_CONFIRMATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_TRADE_CONFIRMATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_TRADE_CONFIRMATION));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesMethod_ELECTRONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMethod_ELECTRONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesMethod_ELECTRONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_ELECTRONIC));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesMethod_TWO_PARTY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMethod_TWO_PARTY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesMethod_TWO_PARTY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_TWO_PARTY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradSesMethod_OPEN_OUTCRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradSesMethod_OPEN_OUTCRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradSesMethod_OPEN_OUTCRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TradSesMethod_OPEN_OUTCRY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeType_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeType_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeType_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeType_AGENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeType_VWAP_GUARANTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeType_VWAP_GUARANTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeType_VWAP_GUARANTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeType_VWAP_GUARANTEE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeType_RISK_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeType_RISK_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeType_RISK_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeType_RISK_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_TradeType_GUARANTEED_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TradeType_GUARANTEED_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TradeType_GUARANTEED_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::TradeType_GUARANTEED_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventCondition_AND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventCondition_AND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventCondition_AND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventCondition_AND));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventCondition_OR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventCondition_OR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventCondition_OR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventCondition_OR));
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_SONIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_SONIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_SONIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_SONIA);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_MUNIAAA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_MUNIAAA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_MUNIAAA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_MUNIAAA);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_LIBID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_LIBID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_LIBID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_LIBID);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_PFANDBRIEFE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_PFANDBRIEFE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_PFANDBRIEFE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_PFANDBRIEFE);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_EUREPO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_EUREPO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_EUREPO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EUREPO);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_FUTURESWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_FUTURESWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_FUTURESWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_FUTURESWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_TREASURY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_TREASURY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_TREASURY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_TREASURY);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_OTHER);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_EURIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_EURIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_EURIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EURIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_EONIA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_EONIA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_EONIA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_EONIA);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_LIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_LIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_LIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_LIBOR);
  return pyobj;
}


SWIGINTERN int Swig_var_BenchmarkCurveName_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BenchmarkCurveName_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BenchmarkCurveName_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BenchmarkCurveName_SWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_CashMargin_MARGIN_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashMargin_MARGIN_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashMargin_MARGIN_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CashMargin_MARGIN_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_CashMargin_MARGIN_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashMargin_MARGIN_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashMargin_MARGIN_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CashMargin_MARGIN_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_CashMargin_CASH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CashMargin_CASH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CashMargin_CASH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CashMargin_CASH));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligTransType_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligTransType_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligTransType_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligTransType_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligTransType_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligTransType_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligTransType_RESTATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligTransType_RESTATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligTransType_RESTATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_RESTATE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlObligTransType_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlObligTransType_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlObligTransType_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlObligTransType_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_PEGGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_PEGGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_PEGGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_PEGGED);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_MARKET_ON_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MARKET_ON_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_MARKET_ON_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_ON_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_SCALE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_SCALE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_SCALE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_SCALE);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_FILL_OR_KILL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_FILL_OR_KILL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_FILL_OR_KILL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_FILL_OR_KILL);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_ALL_OR_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_ALL_OR_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_ALL_OR_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_ALL_OR_NONE);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_NOT_HELD);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_DIRECTED_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_DIRECTED_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_DIRECTED_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_DIRECTED_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_STOP_STOCK_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_STOP_STOCK_TRANSACTION);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_OVER_THE_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_OVER_THE_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_OVER_THE_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_OVER_THE_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_ADD_ON_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_ADD_ON_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_ADD_ON_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_ADD_ON_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_MARKET_AT_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MARKET_AT_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_MARKET_AT_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_AT_CLOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_LIMIT_ON_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_LIMIT_ON_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_LIMIT_ON_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_LIMIT_ON_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_CASH_NOT_HELD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_CASH_NOT_HELD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_CASH_NOT_HELD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_CASH_NOT_HELD);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_MARKET_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MARKET_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_MARKET_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_ON_CLOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_TIME_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_TIME_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_TIME_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_TIME_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_LIMIT_ON_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_LIMIT_ON_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_LIMIT_ON_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_LIMIT_ON_CLOSE);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_TRAILING_STOP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_TRAILING_STOP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_TRAILING_STOP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_TRAILING_STOP);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_WORK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_WORK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_WORK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_WORK);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_RESERVE_SIZE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_RESERVE_SIZE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_RESERVE_SIZE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_RESERVE_SIZE_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_MINIMUM_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MINIMUM_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_MINIMUM_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MINIMUM_QUANTITY);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_MARKET_AT_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_MARKET_AT_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_MARKET_AT_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_MARKET_AT_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_IMBALANCE_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_IMBALANCE_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_IMBALANCE_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_IMBALANCE_ONLY);
  return pyobj;
}


SWIGINTERN int Swig_var_DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION);
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_DO_NOT_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_DO_NOT_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_DO_NOT_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_DO_NOT_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_LARGE_TRADER_SUBMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_LARGE_TRADER_SUBMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_LARGE_TRADER_SUBMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_LARGE_TRADER_SUBMISSION));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_EXERCISE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_EXERCISE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_EXERCISE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_EXERCISE));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_PLEDGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_PLEDGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_PLEDGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_PLEDGE));
  return pyobj;
}


SWIGINTERN int Swig_var_PosTransType_POSITION_ADJUSTMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosTransType_POSITION_ADJUSTMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosTransType_POSITION_ADJUSTMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosTransType_POSITION_ADJUSTMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_Seniority_SUBORDINATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Seniority_SUBORDINATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Seniority_SUBORDINATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::Seniority_SUBORDINATED);
  return pyobj;
}


SWIGINTERN int Swig_var_Seniority_SENIOR_SECURED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Seniority_SENIOR_SECURED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Seniority_SENIOR_SECURED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::Seniority_SENIOR_SECURED);
  return pyobj;
}


SWIGINTERN int Swig_var_Seniority_SENIOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Seniority_SENIOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Seniority_SENIOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::Seniority_SENIOR);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlCurrFxRateCalc_DIVIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlCurrFxRateCalc_DIVIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlCurrFxRateCalc_DIVIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlCurrFxRateCalc_DIVIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_SettlCurrFxRateCalc_MULTIPLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlCurrFxRateCalc_MULTIPLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlCurrFxRateCalc_MULTIPLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::SettlCurrFxRateCalc_MULTIPLY));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintStatus_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintStatus_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_COMPLETED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintStatus_ACCEPTED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_ACCEPTED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintStatus_ACCEPTED_WITH_WARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_ACCEPTED_WITH_WARNINGS));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintStatus_COMPLETED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintStatus_COMPLETED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintStatus_COMPLETED_WITH_WARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintStatus_COMPLETED_WITH_WARNINGS));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_6_MO_LIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_6_MO_LIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_6_MO_LIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_6_MO_LIBOR));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_OLD_5_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_OLD_5 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_OLD_5_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD_5));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_OLD_30_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_OLD_30 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_OLD_30_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD_30));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_3_MO_LIBOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_3_MO_LIBOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_3_MO_LIBOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_3_MO_LIBOR));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_OLD_10_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_OLD_10 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_OLD_10_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_OLD_10));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_CURVE));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_30_YR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_30_YR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_30_YR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_30_YR));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_10_YR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_10_YR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_10_YR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_10_YR));
  return pyobj;
}


SWIGINTERN int Swig_var_Benchmark_5_YR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Benchmark_5_YR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Benchmark_5_YR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Benchmark_5_YR));
  return pyobj;
}


SWIGINTERN int Swig_var_MaturityMonthYearFormat_YEARMONTHWEEK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearFormat_YEARMONTHWEEK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MaturityMonthYearFormat_YEARMONTHWEEK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEARMONTHWEEK));
  return pyobj;
}


SWIGINTERN int Swig_var_MaturityMonthYearFormat_YEARMONTHDAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearFormat_YEARMONTHDAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MaturityMonthYearFormat_YEARMONTHDAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEARMONTHDAY));
  return pyobj;
}


SWIGINTERN int Swig_var_MaturityMonthYearFormat_YEARMONTH_ONLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MaturityMonthYearFormat_YEARMONTH_ONLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MaturityMonthYearFormat_YEARMONTH_ONLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::MaturityMonthYearFormat_YEARMONTH_ONLY));
  return pyobj;
}


SWIGINTERN int Swig_var_LegalConfirm_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegalConfirm_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LegalConfirm_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LegalConfirm_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_LegalConfirm_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LegalConfirm_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LegalConfirm_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LegalConfirm_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReportType_REPORTS_THAT_THE_LAST_MESSAGE_HAS_BEEN_SENT_FOR_THE_APPLIDS_REFER_TO_REFAPPLLASTSEQNUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReportType_REPORTS_THAT_THE_LAST_MESSAGE_HAS_BEEN_SENT_FOR_THE_APPLIDS_REFER_TO_REFAPPLLASTSEQNUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReportType_REPORTS_THAT_THE_LAST_MESSAGE_HAS_BEEN_SENT_FOR_THE_APPLIDS_REFER_TO_REFAPPLLASTSEQNUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReportType_REPORTS_THAT_THE_LAST_MESSAGE_HAS_BEEN_SENT_FOR_THE_APPLIDS_REFER_TO_REFAPPLLASTSEQNUM));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID));
  return pyobj;
}


SWIGINTERN int Swig_var_ReportToExch_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReportToExch_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReportToExch_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ReportToExch_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_ReportToExch_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ReportToExch_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ReportToExch_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ReportToExch_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_ALLOCATED_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_ALLOCATED_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_ALLOCATED_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_ALLOCATED_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_UNKNOWN_ORDERID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_ORDERID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_UNKNOWN_ORDERID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_ORDERID));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_AVERAGEG_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_AVERAGEG_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_AVERAGEG_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_AVERAGEG_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_WAREHOUSE_REQUEST_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_WAREHOUSE_REQUEST_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_WAREHOUSE_REQUEST_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_WAREHOUSE_REQUEST_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_OTHER_99_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_OTHER_99 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_OTHER_99_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_OTHER_99));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_UNKNOWN_LISTID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_LISTID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_UNKNOWN_LISTID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_LISTID));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_INCORRECT_AVERAGE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_INCORRECT_AVERAGE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_INCORRECT_AVERAGE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_INCORRECT_AVERAGE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_UNKNOWN_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_UNKNOWN_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_UNKNOWN_OR_STALE_EXECID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_OR_STALE_EXECID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_UNKNOWN_OR_STALE_EXECID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_OR_STALE_EXECID));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_MISMATCHED_DATA_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_MISMATCHED_DATA_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_MISMATCHED_DATA_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_MISMATCHED_DATA_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_OTHER_7_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_OTHER_7 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_OTHER_7_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_OTHER_7));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_UNKNOWN_CLORDID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_CLORDID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_UNKNOWN_CLORDID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_CLORDID));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_MISMATCHED_DATA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_MISMATCHED_DATA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_MISMATCHED_DATA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_MISMATCHED_DATA));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_CALCULATION_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_CALCULATION_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_CALCULATION_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_CALCULATION_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_COMMISSION_DIFFERENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_COMMISSION_DIFFERENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_COMMISSION_DIFFERENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_COMMISSION_DIFFERENCE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrdIDReason_GTC_FROM_PREVIOUS_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrdIDReason_GTC_FROM_PREVIOUS_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrdIDReason_GTC_FROM_PREVIOUS_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RefOrdIDReason_GTC_FROM_PREVIOUS_DAY));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrdIDReason_PARTIAL_FILL_REMAINING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrdIDReason_PARTIAL_FILL_REMAINING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrdIDReason_PARTIAL_FILL_REMAINING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RefOrdIDReason_PARTIAL_FILL_REMAINING));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrdIDReason_ORDER_CHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrdIDReason_ORDER_CHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrdIDReason_ORDER_CHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::RefOrdIDReason_ORDER_CHANGED));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_SECONDARYORDERID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_SECONDARYORDERID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_SECONDARYORDERID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_SECONDARYORDERID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_ORDERID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_ORDERID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_ORDERID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_ORDERID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_MDENTRYID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_MDENTRYID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_MDENTRYID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_MDENTRYID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_ORIGINAL_ORDER_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_ORIGINAL_ORDER_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_ORIGINAL_ORDER_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_ORIGINAL_ORDER_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_MENTRYID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_MENTRYID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_MENTRYID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_MENTRYID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_QUOTEENTRYID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_QUOTEENTRYID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_QUOTEENTRYID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_QUOTEENTRYID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_QUOTENTRYID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_QUOTENTRYID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_QUOTENTRYID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_QUOTENTRYID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_ORDEID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_ORDEID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_ORDEID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_ORDEID));
  return pyobj;
}


SWIGINTERN int Swig_var_RefOrderIDSource_SECONDARYORDEID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RefOrderIDSource_SECONDARYORDEID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RefOrderIDSource_SECONDARYORDEID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::RefOrderIDSource_SECONDARYORDEID));
  return pyobj;
}


SWIGINTERN int Swig_var_LastCapacity_CROSS_AS_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_CROSS_AS_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastCapacity_CROSS_AS_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_CROSS_AS_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_LastCapacity_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastCapacity_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_LastCapacity_CROSS_AS_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_CROSS_AS_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastCapacity_CROSS_AS_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_CROSS_AS_AGENT));
  return pyobj;
}


SWIGINTERN int Swig_var_LastCapacity_AGENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LastCapacity_AGENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LastCapacity_AGENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LastCapacity_AGENT));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_INSTRUMENT_STRIKE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INSTRUMENT_STRIKE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_INSTRUMENT_STRIKE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_STRIKE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_IN_DEFAULT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_IN_DEFAULT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_IN_DEFAULT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_IN_DEFAULT));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_PRE_REFUNDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_PRE_REFUNDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_PRE_REFUNDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_PRE_REFUNDED));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ORIGINAL_ISSUE_DISCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ORIGINAL_ISSUE_DISCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_UNRATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_UNRATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_UNRATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_UNRATED));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_WHEN_AND_IF_ISSUED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_WHEN_AND_IF_ISSUED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_WHEN_AND_IF_ISSUED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_WHEN_AND_IF_ISSUED));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_CALLABLE_SUPPLY_REDEMPTION_DATE_IN_THE_INSTRATTRIBVALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_CALLABLE_SUPPLY_REDEMPTION_DATE_IN_THE_INSTRATTRIBVALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_CALLABLE_SUPPLY_REDEMPTION_DATE_IN_THE_INSTRATTRIBVALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_CALLABLE_SUPPLY_REDEMPTION_DATE_IN_THE_INSTRATTRIBVALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_STEPPED_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_STEPPED_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_STEPPED_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_STEPPED_COUPON));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_INSTRUMENT_DENOMINATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INSTRUMENT_DENOMINATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_INSTRUMENT_DENOMINATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_DENOMINATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ESCROWED_TO_REDEMPTION_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ESCROWED_TO_REDEMPTION_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_TAXABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_TAXABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_TAXABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TAXABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_INTEREST_BEARING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INTEREST_BEARING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_INTEREST_BEARING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INTEREST_BEARING));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_PREREFUNDED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_PREREFUNDED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_PREREFUNDED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_PREREFUNDED));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_CALLABLE_PUTTABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_CALLABLE_PUTTABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_CALLABLE_PUTTABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_CALLABLE_PUTTABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_COUPON_PERIOD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_COUPON_PERIOD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_COUPON_PERIOD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_COUPON_PERIOD));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_INSTRUMENT_PRICE_PRECISION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INSTRUMENT_PRICE_PRECISION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_INSTRUMENT_PRICE_PRECISION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_PRICE_PRECISION));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_TRADEABLE_INDICATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_TRADEABLE_INDICATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_TRADEABLE_INDICATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TRADEABLE_INDICATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_VARIABLE_RATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_VARIABLE_RATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_VARIABLE_RATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_VARIABLE_RATE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_FLAT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_FLAT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_FLAT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_FLAT));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_INSTRUMENT_NUMERATOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INSTRUMENT_NUMERATOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_INSTRUMENT_NUMERATOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INSTRUMENT_NUMERATOR));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_INDEXED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_INDEXED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_INDEXED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_INDEXED));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_ESCROWED_TO_MATURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ESCROWED_TO_MATURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_ESCROWED_TO_MATURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ESCROWED_TO_MATURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_LESS_FEE_FOR_PUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_LESS_FEE_FOR_PUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_LESS_FEE_FOR_PUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_LESS_FEE_FOR_PUT));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_ZERO_COUPON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_ZERO_COUPON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_ZERO_COUPON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_ZERO_COUPON));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_InstrAttribType_NO_PERIODIC_PAYMENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable InstrAttribType_NO_PERIODIC_PAYMENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_InstrAttribType_NO_PERIODIC_PAYMENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::InstrAttribType_NO_PERIODIC_PAYMENTS));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_FINANCING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_FINANCING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_FINANCING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_FINANCING));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_COMMODITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_COMMODITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_COMMODITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_COMMODITY));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_EQUITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_EQUITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_EQUITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_EQUITY));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_CORPORATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_CORPORATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_CORPORATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_CORPORATE));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_AGENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_MONEYMARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_MONEYMARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_MONEYMARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_MONEYMARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_MORTGAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_MORTGAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_MORTGAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_MORTGAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_CURRENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_CURRENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_CURRENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_CURRENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_INDEX));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_MUNICIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_MUNICIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_MUNICIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_MUNICIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_LOAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_LOAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_LOAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_LOAN));
  return pyobj;
}


SWIGINTERN int Swig_var_Product_GOVERNMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Product_GOVERNMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Product_GOVERNMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::Product_GOVERNMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_FAST_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_FAST_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_FAST_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_FAST_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_NO_OPEN_NO_RESUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NO_OPEN_NO_RESUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_NO_OPEN_NO_RESUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NO_OPEN_NO_RESUME));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_TRADING_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_TRADING_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_TRADING_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRADING_HALT));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_NO_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NO_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_NO_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NO_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_RESUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_RESUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_RESUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_RESUME));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_TRADE_DISSEMINATION_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_TRADE_DISSEMINATION_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_TRADE_DISSEMINATION_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRADE_DISSEMINATION_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_POST_CLOSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_POST_CLOSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_POST_CLOSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_POST_CLOSE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_MARKET_IMBALANCE_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MARKET_IMBALANCE_SELL));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_OPENING_DELAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_OPENING_DELAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_OPENING_DELAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_OPENING_DELAY));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_ITS_PRE_OPENING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_ITS_PRE_OPENING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_ITS_PRE_OPENING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_ITS_PRE_OPENING));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_PRE_CROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_PRE_CROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_PRE_CROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRE_CROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_PRE_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_PRE_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_PRE_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRE_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_BUY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_MARKET_IMBALANCE_BUY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_BUY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MARKET_IMBALANCE_BUY));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_TRADING_RANGE_INDICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_TRADING_RANGE_INDICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_TRADING_RANGE_INDICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_TRADING_RANGE_INDICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_READY_TO_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_READY_TO_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_READY_TO_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_READY_TO_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_NEW_PRICE_INDICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NEW_PRICE_INDICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_NEW_PRICE_INDICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NEW_PRICE_INDICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_OPENING_ROTATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_OPENING_ROTATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_OPENING_ROTATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_OPENING_ROTATION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_PRICE_INDICATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_PRICE_INDICATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_PRICE_INDICATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_PRICE_INDICATION));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_UNKNOWN_OR_INVALID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_UNKNOWN_OR_INVALID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_UNKNOWN_OR_INVALID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_UNKNOWN_OR_INVALID));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL));
  return pyobj;
}


SWIGINTERN int Swig_var_SecurityTradingStatus_NO_MARKET_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SecurityTradingStatus_NO_MARKET_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SecurityTradingStatus_NO_MARKET_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::SecurityTradingStatus_NO_MARKET_IMBALANCE));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SPECIALIST_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SPECIALIST_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SPECIALIST_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SPECIALIST_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_F_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_F is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_F_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_F));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_COMPETING_DEALER_TRADES_O_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_COMPETING_DEALER_TRADES_O is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_COMPETING_DEALER_TRADES_O_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_COMPETING_DEALER_TRADES_O));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_H_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_H is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_H_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_H));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_COMPETING_DEALER_TRADES_R_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_COMPETING_DEALER_TRADES_R is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_COMPETING_DEALER_TRADES_R_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_COMPETING_DEALER_TRADES_R));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_NOT_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_NOT_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_NOT_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_NOT_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_COMPETING_DEALER_TRADES_T_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_COMPETING_DEALER_TRADES_T is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_COMPETING_DEALER_TRADES_T_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_COMPETING_DEALER_TRADES_T));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_AGENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_MEMBER_FIRM_ORG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_MEMBER_FIRM_ORG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_MEMBER_FIRM_ORG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_MEMBER_FIRM_ORG));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_B_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_B is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_B_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_B));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_AGENCY_SINGLE_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_AGENCY_SINGLE_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_AGENCY_SINGLE_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_AGENCY_SINGLE_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY));
  return pyobj;
}


SWIGINTERN int Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_MERGER_REORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_MERGER_REORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_MERGER_REORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_MERGER_REORGANIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_SYMBOL_CONVERSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SYMBOL_CONVERSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_SYMBOL_CONVERSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SYMBOL_CONVERSION));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_SUCCESSION_EVENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SUCCESSION_EVENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_SUCCESSION_EVENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SUCCESSION_EVENT));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_STOCK_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_STOCK_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_STOCK_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_STOCK_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_REVERSE_STOCK_SPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_REVERSE_STOCK_SPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_REVERSE_STOCK_SPLIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_REVERSE_STOCK_SPLIT));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_POSITION_CONSOLIDATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_POSITION_CONSOLIDATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_POSITION_CONSOLIDATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_POSITION_CONSOLIDATION));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_SPINOFF_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SPINOFF is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_SPINOFF_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SPINOFF));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_EX_INTEREST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EX_INTEREST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_EX_INTEREST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_INTEREST));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_LIQUIDATION_REORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_LIQUIDATION_REORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_LIQUIDATION_REORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_LIQUIDATION_REORGANIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_CASH_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_CASH_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_CASH_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_CASH_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_STANDARD_INTEGER_STOCK_SPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_STANDARD_INTEGER_STOCK_SPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_STANDARD_INTEGER_STOCK_SPLIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_STANDARD_INTEGER_STOCK_SPLIT));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_RIGHTS_OFFERING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_RIGHTS_OFFERING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_RIGHTS_OFFERING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_RIGHTS_OFFERING));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_SHAREHOLDER_MEETING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SHAREHOLDER_MEETING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_SHAREHOLDER_MEETING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SHAREHOLDER_MEETING));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_WARRANT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_WARRANT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_WARRANT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_WARRANT));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_EX_RIGHTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EX_RIGHTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_EX_RIGHTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_RIGHTS));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_EX_DISTRIBUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EX_DISTRIBUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_EX_DISTRIBUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_DISTRIBUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_EX_DIVIDEND_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_EX_DIVIDEND is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_EX_DIVIDEND_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_EX_DIVIDEND));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_TENDER_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_TENDER_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_TENDER_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_TENDER_OFFER));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_SPECIAL_ACTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_SPECIAL_ACTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_SPECIAL_ACTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_SPECIAL_ACTION));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_NON_INTEGER_STOCK_SPLIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_NON_INTEGER_STOCK_SPLIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_NON_INTEGER_STOCK_SPLIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_NON_INTEGER_STOCK_SPLIT));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_CUSIP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_CUSIP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_CUSIP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_CUSIP));
  return pyobj;
}


SWIGINTERN int Swig_var_CorporateAction_LEAP_ROLLOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CorporateAction_LEAP_ROLLOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CorporateAction_LEAP_ROLLOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CorporateAction_LEAP_ROLLOVER));
  return pyobj;
}


SWIGINTERN int Swig_var_TerminationType_TERM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TerminationType_TERM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TerminationType_TERM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TerminationType_TERM));
  return pyobj;
}


SWIGINTERN int Swig_var_TerminationType_FLEXIBLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TerminationType_FLEXIBLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TerminationType_FLEXIBLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TerminationType_FLEXIBLE));
  return pyobj;
}


SWIGINTERN int Swig_var_TerminationType_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TerminationType_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TerminationType_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TerminationType_OPEN));
  return pyobj;
}


SWIGINTERN int Swig_var_TerminationType_OVERNIGHT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TerminationType_OVERNIGHT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TerminationType_OVERNIGHT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::TerminationType_OVERNIGHT));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintAction_NEW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_NEW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintAction_NEW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_NEW));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintAction_REPLACE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_REPLACE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintAction_REPLACE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_REPLACE));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintAction_REVERSE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_REVERSE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintAction_REVERSE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_REVERSE));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintAction_CANCEL_USED_TO_REMOVE_THE_OVERALL_TRANSACTION_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_REFERENCE_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_CANCEL_USED_TO_REMOVE_THE_OVERALL_TRANSACTION_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_REFERENCE_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintAction_CANCEL_USED_TO_REMOVE_THE_OVERALL_TRANSACTION_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_REFERENCE_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_CANCEL_USED_TO_REMOVE_THE_OVERALL_TRANSACTION_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_REFERENCE_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintAction_REPLACE_USED_TO_OVERRIDE_THE_OVERALL_TRANSACTION_QUANTITY_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_THE_REFERENCE_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_REPLACE_USED_TO_OVERRIDE_THE_OVERALL_TRANSACTION_QUANTITY_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_THE_REFERENCE_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintAction_REPLACE_USED_TO_OVERRIDE_THE_OVERALL_TRANSACTION_QUANTITY_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_THE_REFERENCE_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_REPLACE_USED_TO_OVERRIDE_THE_OVERALL_TRANSACTION_QUANTITY_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_THE_REFERENCE_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintAction_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintAction_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_PosMaintAction_NEW_USED_TO_INCREMENT_THE_OVERALL_TRANSACTION_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosMaintAction_NEW_USED_TO_INCREMENT_THE_OVERALL_TRANSACTION_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosMaintAction_NEW_USED_TO_INCREMENT_THE_OVERALL_TRANSACTION_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosMaintAction_NEW_USED_TO_INCREMENT_THE_OVERALL_TRANSACTION_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceTimeType_SPECIFIED_DATE_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceTimeType_SPECIFIED_DATE_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceTimeType_SPECIFIED_DATE_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_SPECIFIED_DATE_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceTimeType_EXPIRATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceTimeType_EXPIRATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceTimeType_EXPIRATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_EXPIRATION));
  return pyobj;
}


SWIGINTERN int Swig_var_ComplexEventPriceTimeType_IMMEDIATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ComplexEventPriceTimeType_IMMEDIATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ComplexEventPriceTimeType_IMMEDIATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ComplexEventPriceTimeType_IMMEDIATE));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingFXRateCalc_DIVIDE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingFXRateCalc_DIVIDE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingFXRateCalc_DIVIDE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::UnderlyingFXRateCalc_DIVIDE));
  return pyobj;
}


SWIGINTERN int Swig_var_UnderlyingFXRateCalc_MULTIPLY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable UnderlyingFXRateCalc_MULTIPLY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_UnderlyingFXRateCalc_MULTIPLY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::UnderlyingFXRateCalc_MULTIPLY));
  return pyobj;
}


SWIGINTERN int Swig_var_OddLot_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OddLot_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OddLot_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OddLot_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_OddLot_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OddLot_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OddLot_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::OddLot_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE));
  return pyobj;
}


SWIGINTERN int Swig_var_BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_AND_BOOK_ONE_TRADE_PER_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_AND_BOOK_ONE_TRADE_PER_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_AND_BOOK_ONE_TRADE_PER_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_AND_BOOK_ONE_TRADE_PER_ORDER));
  return pyobj;
}


SWIGINTERN int Swig_var_BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_REJECTED_BY_INTERMEDIARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_REJECTED_BY_INTERMEDIARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_REJECTED_BY_INTERMEDIARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REJECTED_BY_INTERMEDIARY));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_BLOCK_LEVEL_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_BLOCK_LEVEL_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_BLOCK_LEVEL_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_BLOCK_LEVEL_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_ACCOUNT_LEVEL_REJECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_ACCOUNT_LEVEL_REJECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_ACCOUNT_LEVEL_REJECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ACCOUNT_LEVEL_REJECT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_INCOMPLETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_INCOMPLETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_INCOMPLETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_INCOMPLETE));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_ALLOCATION_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_ALLOCATION_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_ALLOCATION_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ALLOCATION_PENDING));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_REVERSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_REVERSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_REVERSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REVERSED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_RECEIVED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_RECEIVED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_RECEIVED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_RECEIVED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_PARTIAL_ACCEPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_PARTIAL_ACCEPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_PARTIAL_ACCEPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_PARTIAL_ACCEPT));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_AllocStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AllocStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AllocStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::AllocStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_IncTaxInd_NET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IncTaxInd_NET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IncTaxInd_NET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::IncTaxInd_NET));
  return pyobj;
}


SWIGINTERN int Swig_var_IncTaxInd_GROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IncTaxInd_GROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IncTaxInd_GROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::IncTaxInd_GROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqStatus_COMPLETED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqStatus_COMPLETED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqStatus_COMPLETED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_COMPLETED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqStatus_REJECTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqStatus_REJECTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqStatus_REJECTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_REJECTED));
  return pyobj;
}


SWIGINTERN int Swig_var_PosReqStatus_COMPLETED_WITH_WARNINGS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PosReqStatus_COMPLETED_WITH_WARNINGS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PosReqStatus_COMPLETED_WITH_WARNINGS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PosReqStatus_COMPLETED_WITH_WARNINGS));
  return pyobj;
}


SWIGINTERN int Swig_var_PriorityIndicator_PRIORITY_UNCHANGED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriorityIndicator_PRIORITY_UNCHANGED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriorityIndicator_PRIORITY_UNCHANGED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriorityIndicator_PRIORITY_UNCHANGED));
  return pyobj;
}


SWIGINTERN int Swig_var_PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE));
  return pyobj;
}


SWIGINTERN int Swig_var_MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT));
  return pyobj;
}


SWIGINTERN int Swig_var_MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION));
  return pyobj;
}


SWIGINTERN int Swig_var_MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION));
  return pyobj;
}


SWIGINTERN int Swig_var_MoneyLaunderingStatus_NOT_CHECKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_NOT_CHECKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MoneyLaunderingStatus_NOT_CHECKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_NOT_CHECKED));
  return pyobj;
}


SWIGINTERN int Swig_var_MoneyLaunderingStatus_PASSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_PASSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MoneyLaunderingStatus_PASSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_PASSED));
  return pyobj;
}


SWIGINTERN int Swig_var_MoneyLaunderingStatus_EXEMPT_1_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXEMPT_1 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MoneyLaunderingStatus_EXEMPT_1_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_1));
  return pyobj;
}


SWIGINTERN int Swig_var_MoneyLaunderingStatus_EXEMPT_2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXEMPT_2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MoneyLaunderingStatus_EXEMPT_2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_2));
  return pyobj;
}


SWIGINTERN int Swig_var_MoneyLaunderingStatus_EXEMPT_3_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MoneyLaunderingStatus_EXEMPT_3 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MoneyLaunderingStatus_EXEMPT_3_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MoneyLaunderingStatus_EXEMPT_3));
  return pyobj;
}


SWIGINTERN int Swig_var_LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE));
  return pyobj;
}


SWIGINTERN int Swig_var_LotType_ROUND_LOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LotType_ROUND_LOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LotType_ROUND_LOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LotType_ROUND_LOT));
  return pyobj;
}


SWIGINTERN int Swig_var_LotType_ODD_LOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LotType_ODD_LOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LotType_ODD_LOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LotType_ODD_LOT));
  return pyobj;
}


SWIGINTERN int Swig_var_LotType_BLOCK_LOT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LotType_BLOCK_LOT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LotType_BLOCK_LOT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::LotType_BLOCK_LOT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_FLAT_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FLAT_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_FLAT_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FLAT_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_REST_OF_BOOK_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_REST_OF_BOOK_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_REST_OF_BOOK_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_REST_OF_BOOK_VWAP);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_TRADING_RANGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_TRADING_RANGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_TRADING_RANGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_TRADING_RANGE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_HALT_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_HALT_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_HALT_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_HALT_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_BID_OFFER_SPECIALIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_BID_OFFER_SPECIALIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_BID_OFFER_SPECIALIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_BID_OFFER_SPECIALIST);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_CROSSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CROSSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_CROSSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CROSSED);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_NO_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NO_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_NO_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NO_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_HALT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_HALT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_HALT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_HALT);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_PREOPENING_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_PREOPENING_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_PREOPENING_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_PREOPENING_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_OPEN_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OPEN_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_OPEN_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OPEN_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_RESERVED_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_RESERVED_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_RESERVED_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_RESERVED_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_OUTRIGHT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OUTRIGHT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_OUTRIGHT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OUTRIGHT_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_IMPLIED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_IMPLIED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_IMPLIED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_IMPLIED_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_DEPTH_ON_OFFER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DEPTH_ON_OFFER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_DEPTH_ON_OFFER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH_ON_OFFER);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_REGULAR_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_REGULAR_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_REGULAR_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_REGULAR_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_ROTATION_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ROTATION_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_ROTATION_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ROTATION_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_EXCHANGE_BEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_EXCHANGE_BEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_EXCHANGE_BEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_EXCHANGE_BEST);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_DEPTH_ON_BID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DEPTH_ON_BID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_DEPTH_ON_BID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH_ON_BID);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_CLOSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CLOSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_CLOSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CLOSING);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_VIEW_OF_COMMON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_VIEW_OF_COMMON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_VIEW_OF_COMMON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_VIEW_OF_COMMON);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_FORBIDDEN_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FORBIDDEN_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_FORBIDDEN_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FORBIDDEN_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_LOCKED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_LOCKED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_LOCKED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_LOCKED);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_ORDER_INFLUX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ORDER_INFLUX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_ORDER_INFLUX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ORDER_INFLUX);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_NEWS_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NEWS_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_NEWS_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NEWS_PENDING);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_RESUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_RESUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_RESUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_RESUME);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_TRADING_RESUME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_TRADING_RESUME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_TRADING_RESUME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_TRADING_RESUME);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_OUT_OF_SEQUENCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OUT_OF_SEQUENCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_OUT_OF_SEQUENCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OUT_OF_SEQUENCE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_END_OF_DAY_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_END_OF_DAY_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_END_OF_DAY_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_END_OF_DAY_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_FROZEN_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FROZEN_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_FROZEN_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FROZEN_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_OPENING_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OPENING_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_OPENING_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OPENING_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_MANUAL_SLOW_QUOTE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_MANUAL_SLOW_QUOTE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_MANUAL_SLOW_QUOTE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_MANUAL_SLOW_QUOTE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_NEWS_DISSEMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NEWS_DISSEMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_NEWS_DISSEMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NEWS_DISSEMINATION);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_DUE_TO_RELATED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DUE_TO_RELATED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_DUE_TO_RELATED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_RELATED);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_VOLUME_ALERT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_VOLUME_ALERT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_VOLUME_ALERT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_VOLUME_ALERT);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_FAST_MARKET_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FAST_MARKET_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_FAST_MARKET_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FAST_MARKET_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_INACTIVE_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_INACTIVE_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_INACTIVE_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_INACTIVE_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_DUE_TO_NEWS_DISSEMINATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DUE_TO_NEWS_DISSEMINATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_DUE_TO_NEWS_DISSEMINATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_NEWS_DISSEMINATION);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_SURVEILLANCE_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_SURVEILLANCE_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_SURVEILLANCE_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_SURVEILLANCE_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_DEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_DEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DEPTH);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_OPEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OPEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_OPEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OPEN);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_AUTOMATIC_EXECUTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_AUTOMATIC_EXECUTION);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_DUE_TO_NEWS_PENDING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_DUE_TO_NEWS_PENDING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_DUE_TO_NEWS_PENDING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_DUE_TO_NEWS_PENDING);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_NO_ACTIVE_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NO_ACTIVE_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_NO_ACTIVE_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NO_ACTIVE_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_OFFER_SPECIALIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OFFER_SPECIALIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_OFFER_SPECIALIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OFFER_SPECIALIST);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_SUSPENDED_SAM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_SUSPENDED_SAM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_SUSPENDED_SAM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_SUSPENDED_SAM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_RESTRICTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_RESTRICTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_RESTRICTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_RESTRICTED);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_NON_FIRM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_NON_FIRM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_NON_FIRM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_NON_FIRM);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_CLOSED_INACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CLOSED_INACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_CLOSED_INACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CLOSED_INACTIVE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_ADDITIONAL_INFO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ADDITIONAL_INFO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_ADDITIONAL_INFO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ADDITIONAL_INFO);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_EQUIPMENT_CHANGEOVER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_EQUIPMENT_CHANGEOVER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_EQUIPMENT_CHANGEOVER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_EQUIPMENT_CHANGEOVER);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_FAST_TRADING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FAST_TRADING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_FAST_TRADING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FAST_TRADING);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_FULL_CURVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_FULL_CURVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_FULL_CURVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_FULL_CURVE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_MEDIAN_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_MEDIAN_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_MEDIAN_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_MEDIAN_PRICE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_OPEN_ACTIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_OPEN_ACTIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_OPEN_ACTIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_OPEN_ACTIVE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_ORDER_IMBALANCE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ORDER_IMBALANCE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_ORDER_IMBALANCE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ORDER_IMBALANCE);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_ETH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_AUTOMATIC_EXECUTION_ETH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_ETH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_AUTOMATIC_EXECUTION_ETH);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_ROTATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_ROTATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_ROTATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_ROTATION);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_BID_SPECIALIST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_BID_SPECIALIST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_BID_SPECIALIST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_BID_SPECIALIST);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_CONSOLIDATED_BEST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CONSOLIDATED_BEST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_CONSOLIDATED_BEST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CONSOLIDATED_BEST);
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteCondition_CLOSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteCondition_CLOSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteCondition_CLOSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::QuoteCondition_CLOSED);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlLocation_EUROCLEAR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_EUROCLEAR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlLocation_EUROCLEAR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_EUROCLEAR);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlLocation_CEDEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_CEDEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlLocation_CEDEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_CEDEL);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlLocation_PARTICIPANT_TRUST_COMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_PARTICIPANT_TRUST_COMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlLocation_PARTICIPANT_TRUST_COMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_PARTICIPANT_TRUST_COMPANY);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlLocation_PHYSICAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_PHYSICAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlLocation_PHYSICAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_PHYSICAL);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlLocation_DEPOSITORY_TRUST_COMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_DEPOSITORY_TRUST_COMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlLocation_DEPOSITORY_TRUST_COMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_DEPOSITORY_TRUST_COMPANY);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_LOCAL_MARKET_SETTLE_LOCATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_LOCAL_MARKET_SETTLE_LOCATION);
  return pyobj;
}


SWIGINTERN int Swig_var_SettlLocation_FEDERAL_BOOK_ENTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SettlLocation_FEDERAL_BOOK_ENTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SettlLocation_FEDERAL_BOOK_ENTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SettlLocation_FEDERAL_BOOK_ENTRY);
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionScope_NATIONAL_EXCLUDING_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionScope_NATIONAL_EXCLUDING_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionScope_NATIONAL_EXCLUDING_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_NATIONAL_EXCLUDING_LOCAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionScope_LOCAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionScope_LOCAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionScope_LOCAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_LOCAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionScope_GLOBAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionScope_GLOBAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionScope_GLOBAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_GLOBAL));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionScope_NATIONAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionScope_NATIONAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionScope_NATIONAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionScope_NATIONAL));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_PUBLIC_COMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_PUBLIC_COMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_PUBLIC_COMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_PUBLIC_COMPANY));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_INDIVIDUAL_TRUSTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_INDIVIDUAL_TRUSTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_INDIVIDUAL_TRUSTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_INDIVIDUAL_TRUSTEE));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_INDIVIDUAL_INVESTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_INDIVIDUAL_INVESTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_INDIVIDUAL_INVESTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_INDIVIDUAL_INVESTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_COMPANY_TRUSTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_COMPANY_TRUSTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_COMPANY_TRUSTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_COMPANY_TRUSTEE));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_PRIVATE_COMPANY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_PRIVATE_COMPANY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_PRIVATE_COMPANY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_PRIVATE_COMPANY));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_NETWORKING_SUB_ACCOUNT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_NETWORKING_SUB_ACCOUNT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_NETWORKING_SUB_ACCOUNT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_NETWORKING_SUB_ACCOUNT));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_PENSION_PLAN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_PENSION_PLAN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_PENSION_PLAN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_PENSION_PLAN));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_TRUSTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_TRUSTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_TRUSTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_TRUSTS));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_FIDUCIARIES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_FIDUCIARIES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_FIDUCIARIES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_FIDUCIARIES));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_NON_PROFIT_ORGANIZATION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_NON_PROFIT_ORGANIZATION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_NON_PROFIT_ORGANIZATION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_NON_PROFIT_ORGANIZATION));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_CORPORATE_BODY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_CORPORATE_BODY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_CORPORATE_BODY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_CORPORATE_BODY));
  return pyobj;
}


SWIGINTERN int Swig_var_OwnerType_NOMINEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable OwnerType_NOMINEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_OwnerType_NOMINEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::OwnerType_NOMINEE));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueResolution_END_SESSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_END_SESSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueResolution_END_SESSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_END_SESSION));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueResolution_QUEUE_FLUSHED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_QUEUE_FLUSHED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueResolution_QUEUE_FLUSHED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_QUEUE_FLUSHED));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueResolution_OVERLAY_LAST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_OVERLAY_LAST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueResolution_OVERLAY_LAST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_OVERLAY_LAST));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplQueueResolution_NO_ACTION_TAKEN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplQueueResolution_NO_ACTION_TAKEN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplQueueResolution_NO_ACTION_TAKEN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplQueueResolution_NO_ACTION_TAKEN));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteResponseLevel_NO_ACKNOWLEDGEMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteResponseLevel_NO_ACKNOWLEDGEMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteResponseLevel_NO_ACKNOWLEDGEMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteResponseLevel_NO_ACKNOWLEDGEMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecAckStatus_RECEIVED_NOT_YET_PROCESSED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecAckStatus_RECEIVED_NOT_YET_PROCESSED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecAckStatus_RECEIVED_NOT_YET_PROCESSED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecAckStatus_RECEIVED_NOT_YET_PROCESSED));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecAckStatus_DONT_KNOW_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecAckStatus_DONT_KNOW is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecAckStatus_DONT_KNOW_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecAckStatus_DONT_KNOW));
  return pyobj;
}


SWIGINTERN int Swig_var_ExecAckStatus_ACCEPTED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ExecAckStatus_ACCEPTED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ExecAckStatus_ACCEPTED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::ExecAckStatus_ACCEPTED));
  return pyobj;
}


SWIGINTERN int Swig_var_NetGrossInd_NET_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetGrossInd_NET is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetGrossInd_NET_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetGrossInd_NET));
  return pyobj;
}


SWIGINTERN int Swig_var_NetGrossInd_GROSS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetGrossInd_GROSS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetGrossInd_GROSS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetGrossInd_GROSS));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlType_PARTIAL_CANCEL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlType_PARTIAL_CANCEL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlType_PARTIAL_CANCEL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CxlType_PARTIAL_CANCEL));
  return pyobj;
}


SWIGINTERN int Swig_var_CxlType_FULL_REMAINING_QUANTITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CxlType_FULL_REMAINING_QUANTITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CxlType_FULL_REMAINING_QUANTITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::CxlType_FULL_REMAINING_QUANTITY));
  return pyobj;
}


SWIGINTERN int Swig_var_DeskTypeSource_NASD_OATS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DeskTypeSource_NASD_OATS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DeskTypeSource_NASD_OATS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DeskTypeSource_NASD_OATS));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionRoundDirection_MORE_AGGRESSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionRoundDirection_MORE_AGGRESSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionRoundDirection_MORE_AGGRESSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MORE_AGGRESSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionRoundDirection_MORE_PASSIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionRoundDirection_MORE_PASSIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionRoundDirection_MORE_PASSIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MORE_PASSIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::DiscretionRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK));
  return pyobj;
}


SWIGINTERN int Swig_var_BidDescriptorType_COUNTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidDescriptorType_COUNTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidDescriptorType_COUNTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_COUNTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_BidDescriptorType_INDEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidDescriptorType_INDEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidDescriptorType_INDEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_INDEX));
  return pyobj;
}


SWIGINTERN int Swig_var_BidDescriptorType_SECTOR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BidDescriptorType_SECTOR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BidDescriptorType_SECTOR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BidDescriptorType_SECTOR));
  return pyobj;
}


SWIGINTERN int Swig_var_NetworkStatusResponseType_INCREMENTAL_UPDATE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkStatusResponseType_INCREMENTAL_UPDATE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetworkStatusResponseType_INCREMENTAL_UPDATE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkStatusResponseType_INCREMENTAL_UPDATE));
  return pyobj;
}


SWIGINTERN int Swig_var_NetworkStatusResponseType_FULL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable NetworkStatusResponseType_FULL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_NetworkStatusResponseType_FULL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::NetworkStatusResponseType_FULL));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteType_INDICATIVE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteType_INDICATIVE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteType_INDICATIVE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteType_INDICATIVE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteType_RESTRICTED_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteType_RESTRICTED_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteType_RESTRICTED_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteType_RESTRICTED_TRADEABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteType_TRADEABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteType_TRADEABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteType_TRADEABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteType_TRADEABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_QuoteType_COUNTER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable QuoteType_COUNTER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_QuoteType_COUNTER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::QuoteType_COUNTER));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_RELATED_TO_MARKET_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_MARKET_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_RELATED_TO_MARKET_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_MARKET_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_RELATED_TO_VWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_VWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_RELATED_TO_VWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_VWAP));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_RELATED_TO_MIDPOINT_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_MIDPOINT_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_RELATED_TO_MIDPOINT_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_MIDPOINT_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_RELATED_TO_DISPLAYED_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_DISPLAYED_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_RELATED_TO_DISPLAYED_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_DISPLAYED_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_RELATED_TO_PRIMARY_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_PRIMARY_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_RELATED_TO_PRIMARY_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_PRIMARY_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_AVERAGE_PRICE_GUARANTEE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_AVERAGE_PRICE_GUARANTEE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_AVERAGE_PRICE_GUARANTEE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_AVERAGE_PRICE_GUARANTEE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_RELATED_TO_LAST_TRADE_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_LAST_TRADE_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_RELATED_TO_LAST_TRADE_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_LAST_TRADE_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossPrioritization_BUY_SIDE_IS_PRIORITIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_BUY_SIDE_IS_PRIORITIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossPrioritization_BUY_SIDE_IS_PRIORITIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_BUY_SIDE_IS_PRIORITIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossPrioritization_SELL_SIDE_IS_PRIORITIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_SELL_SIDE_IS_PRIORITIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossPrioritization_SELL_SIDE_IS_PRIORITIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_SELL_SIDE_IS_PRIORITIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossPrioritization_NONE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_NONE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossPrioritization_NONE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_NONE));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossPrioritization_SELLSIDE_PRIORITIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_SELLSIDE_PRIORITIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossPrioritization_SELLSIDE_PRIORITIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_SELLSIDE_PRIORITIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_CrossPrioritization_BUYSIDE_PRIORITIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CrossPrioritization_BUYSIDE_PRIORITIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CrossPrioritization_BUYSIDE_PRIORITIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::CrossPrioritization_BUYSIDE_PRIORITIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIOthSvc_AUTEX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIOthSvc_AUTEX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIOthSvc_AUTEX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIOthSvc_AUTEX));
  return pyobj;
}


SWIGINTERN int Swig_var_IOIOthSvc_BRIDGE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable IOIOthSvc_BRIDGE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_IOIOthSvc_BRIDGE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::IOIOthSvc_BRIDGE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_MDENTRYTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_MDENTRYTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_MDENTRYTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MDENTRYTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_INSUFFICIENT_CREDIT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_INSUFFICIENT_CREDIT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_INSUFFICIENT_CREDIT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_CREDIT));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_INSUFFICIENT_BANDWIDTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_INSUFFICIENT_BANDWIDTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_INSUFFICIENT_BANDWIDTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_BANDWIDTH));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_SCOPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_SCOPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_SCOPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_SCOPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_DUPLICATE_MDREQID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_DUPLICATE_MDREQID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_DUPLICATE_MDREQID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_DUPLICATE_MDREQID));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_MDUPDATETYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_MDUPDATETYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_MDUPDATETYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MDUPDATETYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNKNOWN_SYMBOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNKNOWN_SYMBOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNKNOWN_SYMBOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNKNOWN_SYMBOL));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_MARKETDEPTH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_MARKETDEPTH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_MARKETDEPTH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MARKETDEPTH));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_INSUFFICIENT_PERMISSIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_INSUFFICIENT_PERMISSIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_INSUFFICIENT_PERMISSIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_INSUFFICIENT_PERMISSIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS));
  return pyobj;
}


SWIGINTERN int Swig_var_ApplReqType_CANCEL_RETRANSMISSION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ApplReqType_CANCEL_RETRANSMISSION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ApplReqType_CANCEL_RETRANSMISSION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::ApplReqType_CANCEL_RETRANSMISSION));
  return pyobj;
}


SWIGINTERN int Swig_var_AggressorIndicator_NO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AggressorIndicator_NO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AggressorIndicator_NO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AggressorIndicator_NO));
  return pyobj;
}


SWIGINTERN int Swig_var_AggressorIndicator_YES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable AggressorIndicator_YES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_AggressorIndicator_YES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(FIX::AggressorIndicator_YES));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKNOWN_SECURITY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNOWN_SECURITY));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_APPLICATION_NOT_AVAILABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_APPLICATION_NOT_AVAILABLE));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_INVALID_PRICE_INCREMENT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_INVALID_PRICE_INCREMENT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_INVALID_PRICE_INCREMENT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_INVALID_PRICE_INCREMENT));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_UNKNOWN_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKNOWN_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_UNKNOWN_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNOWN_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_OTHER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_OTHER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_OTHER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_OTHER));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_UNKNOWN_MESSAGE_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKNOWN_MESSAGE_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_UNKNOWN_MESSAGE_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKNOWN_MESSAGE_TYPE));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_NOT_AUTHORIZED_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_NOT_AUTHORIZED is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_NOT_AUTHORIZED_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_NOT_AUTHORIZED));
  return pyobj;
}


SWIGINTERN int Swig_var_BusinessRejectReason_UNKOWN_ID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BusinessRejectReason_UNKOWN_ID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BusinessRejectReason_UNKOWN_ID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BusinessRejectReason_UNKOWN_ID));
  return pyobj;
}


SWIGINTERN int Swig_var_BookingType_REGULAR_BOOKING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingType_REGULAR_BOOKING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BookingType_REGULAR_BOOKING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BookingType_REGULAR_BOOKING));
  return pyobj;
}


SWIGINTERN int Swig_var_BookingType_CFD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingType_CFD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BookingType_CFD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BookingType_CFD));
  return pyobj;
}


SWIGINTERN int Swig_var_BookingType_TOTAL_RETURN_SWAP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BookingType_TOTAL_RETURN_SWAP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BookingType_TOTAL_RETURN_SWAP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(FIX::BookingType_TOTAL_RETURN_SWAP));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_SessionID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SessionID")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SessionID *)new FIX::SessionID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  FIX::SessionID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_SessionID",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SessionID" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SessionID" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    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_SessionID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SessionID" "', 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 '" "new_SessionID" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SessionID" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "new_SessionID" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SessionID" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SessionID *)new FIX::SessionID((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionID__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  FIX::SessionID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_SessionID",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SessionID" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SessionID" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    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_SessionID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SessionID" "', 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 '" "new_SessionID" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SessionID" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SessionID *)new FIX::SessionID((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionID(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SessionID__SWIG_0(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_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_SessionID__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_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_SessionID__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SessionID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SessionID::SessionID()\n"
    "    FIX::SessionID::SessionID(std::string const &,std::string const &,std::string const &,std::string const &)\n"
    "    FIX::SessionID::SessionID(std::string const &,std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SessionID_getBeginString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::BeginString *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SessionID_getBeginString",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionID_getBeginString" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::BeginString *) &((FIX::SessionID const *)arg1)->getBeginString();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__BeginString, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_getSenderCompID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SenderCompID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SessionID_getSenderCompID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionID_getSenderCompID" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SenderCompID *) &((FIX::SessionID const *)arg1)->getSenderCompID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SenderCompID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_getTargetCompID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::TargetCompID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SessionID_getTargetCompID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionID_getTargetCompID" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::TargetCompID *) &((FIX::SessionID const *)arg1)->getTargetCompID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__TargetCompID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_getSessionQualifier(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SessionID_getSessionQualifier",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionID_getSessionQualifier" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((FIX::SessionID const *)arg1)->getSessionQualifier();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_isFIXT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SessionID_isFIXT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionID_isFIXT" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::SessionID const *)arg1)->isFIXT();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_toString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SessionID_toString",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionID_toString" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::SessionID const *)arg1)->toString();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_toStringFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SessionID_toStringFrozen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionID_toStringFrozen" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((FIX::SessionID const *)arg1)->toStringFrozen();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_fromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 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:SessionID_fromString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionID_fromString" "', argument " "1"" of type '" "FIX::SessionID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(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 '" "SessionID_fromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SessionID_fromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->fromString((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_toString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string temp2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SessionID_toString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionID_toString" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    temp2 = std::string((char*)PyString_AsString(obj1));
    arg2 = &temp2;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &((FIX::SessionID const *)arg1)->toString(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__string, 0 |  0 );
  {
    if( std::string("std::string &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID_toString(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__SessionID, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SessionID_toString__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SessionID_toString__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SessionID_toString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SessionID::toString() const\n"
    "    FIX::SessionID::toString(std::string &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SessionID___invert__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SessionID result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SessionID___invert__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionID___invert__" "', argument " "1"" of type '" "FIX::SessionID const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::SessionID const *)arg1)->operator ~();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new FIX::SessionID(static_cast< const FIX::SessionID& >(result))), SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionID___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SessionID___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionID___str__" "', argument " "1"" of type '" "FIX::SessionID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = FIX_SessionID___str__(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SessionID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = (FIX::SessionID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SessionID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SessionID" "', argument " "1"" of type '" "FIX::SessionID *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SessionID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SessionID, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap___lt____SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  FIX::SessionID *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:__lt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lt__" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lt__" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator <((FIX::SessionID const &)*arg1,(FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___lt__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__StringField, 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___lt____SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionID, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____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_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_1(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___eq____SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  FIX::SessionID *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:__eq__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator ==((FIX::SessionID const &)*arg1,(FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___eq__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__StringField, 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___eq____SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionID, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____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_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_1(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___ne____SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  FIX::SessionID *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:__ne__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::operator !=((FIX::SessionID const &)*arg1,(FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___ne__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__StringField, 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___ne____SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__StringField, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ne____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionID, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ne____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_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ne____SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__StringField, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ne____SWIG_1(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  FIX::SessionID *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__ostream,  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_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::ostream *) &FIX::operator <<(*arg1,(FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___rshift____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::istream *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__istream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__rshift__" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__rshift__" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__rshift__" "', argument " "2"" of type '" "FIX::SessionID &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__rshift__" "', argument " "2"" of type '" "FIX::SessionID &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::istream *) &FIX::operator >>(*arg1,*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__istream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dictionary__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::Dictionary *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Dictionary",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Dictionary" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Dictionary" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Dictionary *)new FIX::Dictionary((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dictionary__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Dictionary")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Dictionary *)new FIX::Dictionary();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Dictionary(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_Dictionary__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_Dictionary__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Dictionary'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Dictionary::Dictionary(std::string const &)\n"
    "    FIX::Dictionary::Dictionary()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Dictionary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Dictionary",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dictionary" "', argument " "1"" of type '" "FIX::Dictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_getName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getName" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::Dictionary const *)arg1)->getName();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_size" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::Dictionary const *)arg1)->size();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Dictionary_getString",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getString" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(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 '" "Dictionary_getString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_getString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_getString" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = ((FIX::Dictionary const *)arg1)->getString((std::string const &)*arg2,arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  catch(FIX::FieldConvertError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldConvertError(static_cast< const FIX::FieldConvertError& >(_e))),SWIGTYPE_p_FIX__FieldConvertError,SWIG_POINTER_OWN), "FIX::FieldConvertError", SWIGTYPE_p_FIX__FieldConvertError); SWIG_fail;
  }
  
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 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:Dictionary_getString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getString" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(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 '" "Dictionary_getString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_getString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = ((FIX::Dictionary const *)arg1)->getString((std::string const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  catch(FIX::FieldConvertError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldConvertError(static_cast< const FIX::FieldConvertError& >(_e))),SWIGTYPE_p_FIX__FieldConvertError,SWIG_POINTER_OWN), "FIX::FieldConvertError", SWIGTYPE_p_FIX__FieldConvertError); SWIG_fail;
  }
  
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getString(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Dictionary, 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_Dictionary_getString__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Dictionary, 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_Dictionary_getString__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Dictionary_getString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Dictionary::getString(std::string const &,bool) const\n"
    "    FIX::Dictionary::getString(std::string const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Dictionary_getLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Dictionary_getLong",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getLong" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(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 '" "Dictionary_getLong" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_getLong" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (long)((FIX::Dictionary const *)arg1)->getLong((std::string const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  catch(FIX::FieldConvertError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldConvertError(static_cast< const FIX::FieldConvertError& >(_e))),SWIGTYPE_p_FIX__FieldConvertError,SWIG_POINTER_OWN), "FIX::FieldConvertError", SWIGTYPE_p_FIX__FieldConvertError); SWIG_fail;
  }
  
  resultobj = SWIG_From_long(static_cast< long >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 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:Dictionary_getDouble",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getDouble" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(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 '" "Dictionary_getDouble" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_getDouble" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (double)((FIX::Dictionary const *)arg1)->getDouble((std::string const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  catch(FIX::FieldConvertError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldConvertError(static_cast< const FIX::FieldConvertError& >(_e))),SWIGTYPE_p_FIX__FieldConvertError,SWIG_POINTER_OWN), "FIX::FieldConvertError", SWIGTYPE_p_FIX__FieldConvertError); SWIG_fail;
  }
  
  resultobj = SWIG_From_double(static_cast< double >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 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:Dictionary_getBool",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getBool" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(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 '" "Dictionary_getBool" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_getBool" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)((FIX::Dictionary const *)arg1)->getBool((std::string const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  catch(FIX::FieldConvertError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldConvertError(static_cast< const FIX::FieldConvertError& >(_e))),SWIGTYPE_p_FIX__FieldConvertError,SWIG_POINTER_OWN), "FIX::FieldConvertError", SWIGTYPE_p_FIX__FieldConvertError); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_getDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 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:Dictionary_getDay",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_getDay" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(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 '" "Dictionary_getDay" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_getDay" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (int)((FIX::Dictionary const *)arg1)->getDay((std::string const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  catch(FIX::FieldConvertError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldConvertError(static_cast< const FIX::FieldConvertError& >(_e))),SWIGTYPE_p_FIX__FieldConvertError,SWIG_POINTER_OWN), "FIX::FieldConvertError", SWIGTYPE_p_FIX__FieldConvertError); SWIG_fail;
  }
  
  resultobj = SWIG_From_int(static_cast< int >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_setString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 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:Dictionary_setString",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_setString" "', argument " "1"" of type '" "FIX::Dictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(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 '" "Dictionary_setString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_setString" "', 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 '" "Dictionary_setString" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_setString" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setString((std::string const &)*arg2,(std::string const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  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_Dictionary_setLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  long val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Dictionary_setLong",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_setLong" "', argument " "1"" of type '" "FIX::Dictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(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 '" "Dictionary_setLong" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_setLong" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_long(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_setLong" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setLong((std::string const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_setDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Dictionary_setDouble",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_setDouble" "', argument " "1"" of type '" "FIX::Dictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(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 '" "Dictionary_setDouble" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_setDouble" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_setDouble" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setDouble((std::string const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_setBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Dictionary_setBool",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_setBool" "', argument " "1"" of type '" "FIX::Dictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(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 '" "Dictionary_setBool" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_setBool" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_setBool" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setBool((std::string const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_setDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Dictionary_setDay",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_setDay" "', argument " "1"" of type '" "FIX::Dictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(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 '" "Dictionary_setDay" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_setDay" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Dictionary_setDay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setDay((std::string const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_has(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 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:Dictionary_has",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_has" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(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 '" "Dictionary_has" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_has" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::Dictionary const *)arg1)->has((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_merge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  FIX::Dictionary *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:Dictionary_merge",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_merge" "', argument " "1"" of type '" "FIX::Dictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Dictionary,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dictionary_merge" "', argument " "2"" of type '" "FIX::Dictionary const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dictionary_merge" "', argument " "2"" of type '" "FIX::Dictionary const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Dictionary * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->merge((FIX::Dictionary const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Dictionary::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_begin" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::Dictionary const *)arg1)->begin();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new FIX::Dictionary::iterator(static_cast< const FIX::Dictionary::iterator& >(result))), SWIGTYPE_p_FIX__Dictionary__Data__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Dictionary_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Dictionary *arg1 = (FIX::Dictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Dictionary::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Dictionary_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dictionary_end" "', argument " "1"" of type '" "FIX::Dictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Dictionary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::Dictionary const *)arg1)->end();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new FIX::Dictionary::iterator(static_cast< const FIX::Dictionary::iterator& >(result))), SWIGTYPE_p_FIX__Dictionary__Data__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Dictionary_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Dictionary, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN int Swig_var_BEGINSTRING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable BEGINSTRING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_BEGINSTRING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::BEGINSTRING);
  return pyobj;
}


SWIGINTERN int Swig_var_SENDERCOMPID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SENDERCOMPID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SENDERCOMPID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SENDERCOMPID);
  return pyobj;
}


SWIGINTERN int Swig_var_TARGETCOMPID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TARGETCOMPID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TARGETCOMPID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TARGETCOMPID);
  return pyobj;
}


SWIGINTERN int Swig_var_SESSION_QUALIFIER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SESSION_QUALIFIER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SESSION_QUALIFIER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SESSION_QUALIFIER);
  return pyobj;
}


SWIGINTERN int Swig_var_DEFAULT_APPLVERID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DEFAULT_APPLVERID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DEFAULT_APPLVERID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DEFAULT_APPLVERID);
  return pyobj;
}


SWIGINTERN int Swig_var_CONNECTION_TYPE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CONNECTION_TYPE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CONNECTION_TYPE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CONNECTION_TYPE);
  return pyobj;
}


SWIGINTERN int Swig_var_USE_DATA_DICTIONARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable USE_DATA_DICTIONARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_USE_DATA_DICTIONARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::USE_DATA_DICTIONARY);
  return pyobj;
}


SWIGINTERN int Swig_var_SEND_RESETSEQNUMFLAG_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SEND_RESETSEQNUMFLAG is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SEND_RESETSEQNUMFLAG_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SEND_RESETSEQNUMFLAG);
  return pyobj;
}


SWIGINTERN int Swig_var_SEND_REDUNDANT_RESENDREQUESTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SEND_REDUNDANT_RESENDREQUESTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SEND_REDUNDANT_RESENDREQUESTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SEND_REDUNDANT_RESENDREQUESTS);
  return pyobj;
}


SWIGINTERN int Swig_var_DATA_DICTIONARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DATA_DICTIONARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DATA_DICTIONARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::DATA_DICTIONARY);
  return pyobj;
}


SWIGINTERN int Swig_var_TRANSPORT_DATA_DICTIONARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TRANSPORT_DATA_DICTIONARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TRANSPORT_DATA_DICTIONARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::TRANSPORT_DATA_DICTIONARY);
  return pyobj;
}


SWIGINTERN int Swig_var_APP_DATA_DICTIONARY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable APP_DATA_DICTIONARY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_APP_DATA_DICTIONARY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::APP_DATA_DICTIONARY);
  return pyobj;
}


SWIGINTERN int Swig_var_USE_LOCAL_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable USE_LOCAL_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_USE_LOCAL_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::USE_LOCAL_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_START_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable START_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_START_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::START_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_END_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable END_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_END_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::END_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_START_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable START_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_START_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::START_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_END_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable END_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_END_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::END_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_LOGON_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGON_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LOGON_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGON_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_LOGOUT_TIME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGOUT_TIME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LOGOUT_TIME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGOUT_TIME);
  return pyobj;
}


SWIGINTERN int Swig_var_LOGON_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGON_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LOGON_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGON_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_LOGOUT_DAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGOUT_DAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LOGOUT_DAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGOUT_DAY);
  return pyobj;
}


SWIGINTERN int Swig_var_CHECK_COMPID_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CHECK_COMPID is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CHECK_COMPID_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CHECK_COMPID);
  return pyobj;
}


SWIGINTERN int Swig_var_CHECK_LATENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable CHECK_LATENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_CHECK_LATENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::CHECK_LATENCY);
  return pyobj;
}


SWIGINTERN int Swig_var_MAX_LATENCY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MAX_LATENCY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MAX_LATENCY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MAX_LATENCY);
  return pyobj;
}


SWIGINTERN int Swig_var_HEARTBTINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HEARTBTINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HEARTBTINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::HEARTBTINT);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_ACCEPT_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_ACCEPT_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_ACCEPT_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_ACCEPT_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_REUSE_ADDRESS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_REUSE_ADDRESS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_REUSE_ADDRESS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_REUSE_ADDRESS);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_CONNECT_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_CONNECT_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_CONNECT_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_CONNECT_HOST);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_CONNECT_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_CONNECT_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_CONNECT_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_CONNECT_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_NODELAY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_NODELAY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_NODELAY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_NODELAY);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_SEND_BUFFER_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_SEND_BUFFER_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_SEND_BUFFER_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_SEND_BUFFER_SIZE);
  return pyobj;
}


SWIGINTERN int Swig_var_SOCKET_RECEIVE_BUFFER_SIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SOCKET_RECEIVE_BUFFER_SIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SOCKET_RECEIVE_BUFFER_SIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SOCKET_RECEIVE_BUFFER_SIZE);
  return pyobj;
}


SWIGINTERN int Swig_var_RECONNECT_INTERVAL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RECONNECT_INTERVAL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RECONNECT_INTERVAL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RECONNECT_INTERVAL);
  return pyobj;
}


SWIGINTERN int Swig_var_VALIDATE_LENGTH_AND_CHECKSUM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VALIDATE_LENGTH_AND_CHECKSUM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VALIDATE_LENGTH_AND_CHECKSUM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::VALIDATE_LENGTH_AND_CHECKSUM);
  return pyobj;
}


SWIGINTERN int Swig_var_VALIDATE_FIELDS_OUT_OF_ORDER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VALIDATE_FIELDS_OUT_OF_ORDER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VALIDATE_FIELDS_OUT_OF_ORDER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::VALIDATE_FIELDS_OUT_OF_ORDER);
  return pyobj;
}


SWIGINTERN int Swig_var_VALIDATE_FIELDS_HAVE_VALUES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VALIDATE_FIELDS_HAVE_VALUES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VALIDATE_FIELDS_HAVE_VALUES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::VALIDATE_FIELDS_HAVE_VALUES);
  return pyobj;
}


SWIGINTERN int Swig_var_VALIDATE_USER_DEFINED_FIELDS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable VALIDATE_USER_DEFINED_FIELDS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_VALIDATE_USER_DEFINED_FIELDS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::VALIDATE_USER_DEFINED_FIELDS);
  return pyobj;
}


SWIGINTERN int Swig_var_LOGON_TIMEOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGON_TIMEOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LOGON_TIMEOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGON_TIMEOUT);
  return pyobj;
}


SWIGINTERN int Swig_var_LOGOUT_TIMEOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LOGOUT_TIMEOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LOGOUT_TIMEOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::LOGOUT_TIMEOUT);
  return pyobj;
}


SWIGINTERN int Swig_var_FILE_STORE_PATH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FILE_STORE_PATH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FILE_STORE_PATH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FILE_STORE_PATH);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_STORE_USECONNECTIONPOOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_USECONNECTIONPOOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_STORE_USECONNECTIONPOOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_USECONNECTIONPOOL);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_STORE_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_STORE_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_DATABASE);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_STORE_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_STORE_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_USER);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_STORE_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_STORE_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_PASSWORD);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_STORE_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_STORE_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_HOST);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_STORE_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_STORE_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_STORE_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_STORE_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_STORE_USECONNECTIONPOOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_USECONNECTIONPOOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_STORE_USECONNECTIONPOOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_USECONNECTIONPOOL);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_STORE_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_STORE_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_DATABASE);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_STORE_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_STORE_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_USER);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_STORE_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_STORE_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_PASSWORD);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_STORE_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_STORE_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_HOST);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_STORE_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_STORE_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_STORE_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_STORE_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_STORE_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_STORE_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_STORE_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_STORE_USER);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_STORE_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_STORE_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_STORE_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_STORE_PASSWORD);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_STORE_CONNECTION_STRING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_STORE_CONNECTION_STRING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_STORE_CONNECTION_STRING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_STORE_CONNECTION_STRING);
  return pyobj;
}


SWIGINTERN int Swig_var_FILE_LOG_PATH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FILE_LOG_PATH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FILE_LOG_PATH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FILE_LOG_PATH);
  return pyobj;
}


SWIGINTERN int Swig_var_FILE_LOG_BACKUP_PATH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable FILE_LOG_BACKUP_PATH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_FILE_LOG_BACKUP_PATH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::FILE_LOG_BACKUP_PATH);
  return pyobj;
}


SWIGINTERN int Swig_var_SCREEN_LOG_SHOW_INCOMING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SCREEN_LOG_SHOW_INCOMING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SCREEN_LOG_SHOW_INCOMING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_INCOMING);
  return pyobj;
}


SWIGINTERN int Swig_var_SCREEN_LOG_SHOW_OUTGOING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SCREEN_LOG_SHOW_OUTGOING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SCREEN_LOG_SHOW_OUTGOING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_OUTGOING);
  return pyobj;
}


SWIGINTERN int Swig_var_SCREEN_LOG_SHOW_EVENTS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SCREEN_LOG_SHOW_EVENTS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SCREEN_LOG_SHOW_EVENTS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::SCREEN_LOG_SHOW_EVENTS);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_USECONNECTIONPOOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_USECONNECTIONPOOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_USECONNECTIONPOOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_USECONNECTIONPOOL);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_DATABASE);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_USER);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_PASSWORD);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_HOST);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_INCOMING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_INCOMING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_INCOMING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_INCOMING_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_OUTGOING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_OUTGOING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_OUTGOING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_OUTGOING_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_MYSQL_LOG_EVENT_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MYSQL_LOG_EVENT_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MYSQL_LOG_EVENT_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MYSQL_LOG_EVENT_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_USECONNECTIONPOOL_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_USECONNECTIONPOOL is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_USECONNECTIONPOOL_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_USECONNECTIONPOOL);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_DATABASE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_DATABASE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_DATABASE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_DATABASE);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_USER);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_PASSWORD);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_HOST_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_HOST is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_HOST_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_HOST);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_INCOMING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_INCOMING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_INCOMING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_INCOMING_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_OUTGOING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_OUTGOING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_OUTGOING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_OUTGOING_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_POSTGRESQL_LOG_EVENT_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable POSTGRESQL_LOG_EVENT_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_POSTGRESQL_LOG_EVENT_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::POSTGRESQL_LOG_EVENT_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_LOG_USER_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_USER is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_LOG_USER_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_USER);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_LOG_PASSWORD_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_PASSWORD is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_LOG_PASSWORD_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_PASSWORD);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_LOG_CONNECTION_STRING_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_CONNECTION_STRING is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_LOG_CONNECTION_STRING_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_CONNECTION_STRING);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_LOG_INCOMING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_INCOMING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_LOG_INCOMING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_INCOMING_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_LOG_OUTGOING_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_OUTGOING_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_LOG_OUTGOING_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_OUTGOING_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_ODBC_LOG_EVENT_TABLE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ODBC_LOG_EVENT_TABLE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ODBC_LOG_EVENT_TABLE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::ODBC_LOG_EVENT_TABLE);
  return pyobj;
}


SWIGINTERN int Swig_var_RESET_ON_LOGON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RESET_ON_LOGON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RESET_ON_LOGON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RESET_ON_LOGON);
  return pyobj;
}


SWIGINTERN int Swig_var_RESET_ON_LOGOUT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RESET_ON_LOGOUT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RESET_ON_LOGOUT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RESET_ON_LOGOUT);
  return pyobj;
}


SWIGINTERN int Swig_var_RESET_ON_DISCONNECT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable RESET_ON_DISCONNECT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_RESET_ON_DISCONNECT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::RESET_ON_DISCONNECT);
  return pyobj;
}


SWIGINTERN int Swig_var_REFRESH_ON_LOGON_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable REFRESH_ON_LOGON is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_REFRESH_ON_LOGON_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::REFRESH_ON_LOGON);
  return pyobj;
}


SWIGINTERN int Swig_var_MILLISECONDS_IN_TIMESTAMP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MILLISECONDS_IN_TIMESTAMP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MILLISECONDS_IN_TIMESTAMP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::MILLISECONDS_IN_TIMESTAMP);
  return pyobj;
}


SWIGINTERN int Swig_var_HTTP_ACCEPT_PORT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HTTP_ACCEPT_PORT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HTTP_ACCEPT_PORT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::HTTP_ACCEPT_PORT);
  return pyobj;
}


SWIGINTERN int Swig_var_PERSIST_MESSAGES_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PERSIST_MESSAGES is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PERSIST_MESSAGES_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(FIX::PERSIST_MESSAGES);
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_SessionSettings__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SessionSettings")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SessionSettings *)new FIX::SessionSettings();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionSettings__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SessionSettings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SessionSettings",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__istream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SessionSettings" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SessionSettings" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::SessionSettings *)new FIX::SessionSettings(*arg1);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionSettings__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::SessionSettings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SessionSettings",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SessionSettings" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SessionSettings" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::SessionSettings *)new FIX::SessionSettings((std::string const &)*arg1);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SessionSettings(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_SessionSettings__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SessionSettings__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_SessionSettings__SWIG_2(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SessionSettings'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SessionSettings::SessionSettings()\n"
    "    FIX::SessionSettings::SessionSettings(std::istream &)\n"
    "    FIX::SessionSettings::SessionSettings(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SessionSettings_has(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  FIX::SessionID *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:SessionSettings_has",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionSettings_has" "', argument " "1"" of type '" "FIX::SessionSettings const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionSettings_has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SessionSettings_has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::SessionSettings const *)arg1)->has((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::Dictionary *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SessionSettings_get",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionSettings_get" "', argument " "1"" of type '" "FIX::SessionSettings const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionSettings_get" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SessionSettings_get" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::Dictionary *) &((FIX::SessionSettings const *)arg1)->get((FIX::SessionID const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_set__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  FIX::Dictionary arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SessionSettings_set",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionSettings_set" "', argument " "1"" of type '" "FIX::SessionSettings *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionSettings_set" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SessionSettings_set" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__Dictionary,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SessionSettings_set" "', argument " "3"" of type '" "FIX::Dictionary""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SessionSettings_set" "', argument " "3"" of type '" "FIX::Dictionary""'");
    } else {
      FIX::Dictionary * temp = reinterpret_cast< FIX::Dictionary * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->set((FIX::SessionID const &)*arg2,arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Dictionary *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SessionSettings_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionSettings_get" "', argument " "1"" of type '" "FIX::SessionSettings const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Dictionary *) &((FIX::SessionSettings const *)arg1)->get();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_get(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SessionSettings_get__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SessionSettings_get__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SessionSettings_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SessionSettings::get(FIX::SessionID const &) const\n"
    "    FIX::SessionSettings::get() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SessionSettings_set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  FIX::Dictionary *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:SessionSettings_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionSettings_set" "', argument " "1"" of type '" "FIX::SessionSettings *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Dictionary,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SessionSettings_set" "', argument " "2"" of type '" "FIX::Dictionary const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SessionSettings_set" "', argument " "2"" of type '" "FIX::Dictionary const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Dictionary * >(argp2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->set((FIX::Dictionary const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_set(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__Dictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SessionSettings_set__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__Dictionary, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SessionSettings_set__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SessionSettings_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SessionSettings::set(FIX::SessionID const &,FIX::Dictionary)\n"
    "    FIX::SessionSettings::set(FIX::Dictionary const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SessionSettings_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SessionSettings_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionSettings_size" "', argument " "1"" of type '" "FIX::SessionSettings const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::SessionSettings const *)arg1)->size();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SessionSettings_getSessions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::set< FIX::SessionID > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SessionSettings_getSessions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionSettings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionSettings_getSessions" "', argument " "1"" of type '" "FIX::SessionSettings const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::SessionSettings const *)arg1)->getSessions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new std::set< FIX::SessionID >(static_cast< const std::set< FIX::SessionID >& >(result))), SWIGTYPE_p_std__setT_FIX__SessionID_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SessionSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = (FIX::SessionSettings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SessionSettings",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SessionSettings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SessionSettings" "', argument " "1"" of type '" "FIX::SessionSettings *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SessionSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SessionSettings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap___rshift____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  FIX::SessionSettings *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::istream *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__istream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__rshift__" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__rshift__" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionSettings,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__rshift__" "', argument " "2"" of type '" "FIX::SessionSettings &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__rshift__" "', argument " "2"" of type '" "FIX::SessionSettings &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionSettings * >(argp2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (std::istream *) &FIX::operator >>(*arg1,*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__istream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___rshift__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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__istream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___rshift____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionSettings, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___rshift____SWIG_1(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lshift____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  FIX::SessionSettings *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__ostream,  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_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionSettings * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::ostream *) &FIX::operator <<(*arg1,(FIX::SessionSettings const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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__ostream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__FieldBase, 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__ostream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__Message, 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__ostream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, 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__ostream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionSettings, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_3(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_new_Session(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Application *arg1 = 0 ;
  MessageStoreFactory *arg2 = 0 ;
  FIX::SessionID *arg3 = 0 ;
  DataDictionaryProvider *arg4 = 0 ;
  TimeRange *arg5 = 0 ;
  int arg6 ;
  LogFactory *arg7 = (LogFactory *) 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 ;
  FIX::Session *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_Session",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Session" "', argument " "1"" of type '" "Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Session" "', argument " "1"" of type '" "Application &""'"); 
  }
  arg1 = reinterpret_cast< Application * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Session" "', argument " "2"" of type '" "MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Session" "', argument " "2"" of type '" "MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Session" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Session" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_DataDictionaryProvider,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Session" "', argument " "4"" of type '" "DataDictionaryProvider const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Session" "', argument " "4"" of type '" "DataDictionaryProvider const &""'"); 
  }
  arg4 = reinterpret_cast< DataDictionaryProvider * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_TimeRange,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Session" "', argument " "5"" of type '" "TimeRange const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Session" "', argument " "5"" of type '" "TimeRange const &""'"); 
  }
  arg5 = reinterpret_cast< TimeRange * >(argp5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Session" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_LogFactory, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Session" "', argument " "7"" of type '" "LogFactory *""'"); 
  }
  arg7 = reinterpret_cast< LogFactory * >(argp7);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Session *)new FIX::Session(*arg1,*arg2,(FIX::SessionID const &)*arg3,(DataDictionaryProvider const &)*arg4,(TimeRange const &)*arg5,arg6,arg7);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Session(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Session",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Session" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_logon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_logon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_logon" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->logon();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_logout__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_logout",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_logout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(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 '" "Session_logout" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_logout" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->logout((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_logout__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_logout",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_logout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->logout();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_logout(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Session_logout__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 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_Session_logout__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Session_logout'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Session::logout(std::string const &)\n"
    "    FIX::Session::logout()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Session_isEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_isEnabled",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_isEnabled" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->isEnabled();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sentLogon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_sentLogon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_sentLogon" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->sentLogon();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sentLogout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_sentLogout",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_sentLogout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->sentLogout();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_receivedLogon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_receivedLogon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_receivedLogon" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->receivedLogon();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isLoggedOn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_isLoggedOn",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_isLoggedOn" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->isLoggedOn();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_reset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_reset" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->reset();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_refresh",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_refresh" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->refresh();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setNextSenderMsgSeqNum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setNextSenderMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setNextSenderMsgSeqNum(arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setNextTargetMsgSeqNum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setNextTargetMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setNextTargetMsgSeqNum(arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getSessionID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SessionID *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getSessionID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getSessionID" "', argument " "1"" of type '" "FIX::Session const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SessionID *) &((FIX::Session const *)arg1)->getSessionID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SessionID, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setDataDictionaryProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  DataDictionaryProvider *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:Session_setDataDictionaryProvider",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setDataDictionaryProvider" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_DataDictionaryProvider,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_setDataDictionaryProvider" "', argument " "2"" of type '" "DataDictionaryProvider const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_setDataDictionaryProvider" "', argument " "2"" of type '" "DataDictionaryProvider const &""'"); 
  }
  arg2 = reinterpret_cast< DataDictionaryProvider * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setDataDictionaryProvider((DataDictionaryProvider const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getDataDictionaryProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  DataDictionaryProvider *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getDataDictionaryProvider",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getDataDictionaryProvider" "', argument " "1"" of type '" "FIX::Session const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (DataDictionaryProvider *) &((FIX::Session const *)arg1)->getDataDictionaryProvider();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DataDictionaryProvider, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 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:Session_sendToTarget",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(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 '" "Session_sendToTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)FIX::Session::sendToTarget(*arg1,(std::string const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::SessionNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::SessionNotFound(static_cast< const FIX::SessionNotFound& >(_e))),SWIGTYPE_p_FIX__SessionNotFound,SWIG_POINTER_OWN), "FIX::SessionNotFound", SWIGTYPE_p_FIX__SessionNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_sendToTarget",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)FIX::Session::sendToTarget(*arg1);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::SessionNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::SessionNotFound(static_cast< const FIX::SessionNotFound& >(_e))),SWIGTYPE_p_FIX__SessionNotFound,SWIG_POINTER_OWN), "FIX::SessionNotFound", SWIGTYPE_p_FIX__SessionNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  FIX::SessionID *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:Session_sendToTarget",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_sendToTarget" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)FIX::Session::sendToTarget(*arg1,(FIX::SessionID const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::SessionNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::SessionNotFound(static_cast< const FIX::SessionNotFound& >(_e))),SWIGTYPE_p_FIX__SessionNotFound,SWIG_POINTER_OWN), "FIX::SessionNotFound", SWIGTYPE_p_FIX__SessionNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  FIX::SenderCompID *arg2 = 0 ;
  FIX::TargetCompID *arg3 = 0 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Session_sendToTarget",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SenderCompID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_sendToTarget" "', argument " "2"" of type '" "FIX::SenderCompID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "2"" of type '" "FIX::SenderCompID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SenderCompID * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__TargetCompID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Session_sendToTarget" "', argument " "3"" of type '" "FIX::TargetCompID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "3"" of type '" "FIX::TargetCompID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::TargetCompID * >(argp3);
  {
    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 '" "Session_sendToTarget" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)FIX::Session::sendToTarget(*arg1,(FIX::SenderCompID const &)*arg2,(FIX::TargetCompID const &)*arg3,(std::string const &)*arg4);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::SessionNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::SessionNotFound(static_cast< const FIX::SessionNotFound& >(_e))),SWIGTYPE_p_FIX__SessionNotFound,SWIG_POINTER_OWN), "FIX::SessionNotFound", SWIGTYPE_p_FIX__SessionNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  FIX::SenderCompID *arg2 = 0 ;
  FIX::TargetCompID *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:Session_sendToTarget",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SenderCompID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_sendToTarget" "', argument " "2"" of type '" "FIX::SenderCompID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "2"" of type '" "FIX::SenderCompID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SenderCompID * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__TargetCompID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Session_sendToTarget" "', argument " "3"" of type '" "FIX::TargetCompID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "3"" of type '" "FIX::TargetCompID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::TargetCompID * >(argp3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)FIX::Session::sendToTarget(*arg1,(FIX::SenderCompID const &)*arg2,(FIX::TargetCompID const &)*arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::SessionNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::SessionNotFound(static_cast< const FIX::SessionNotFound& >(_e))),SWIGTYPE_p_FIX__SessionNotFound,SWIG_POINTER_OWN), "FIX::SessionNotFound", SWIGTYPE_p_FIX__SessionNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Session_sendToTarget",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(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 '" "Session_sendToTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', 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 '" "Session_sendToTarget" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "Session_sendToTarget" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)FIX::Session::sendToTarget(*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::SessionNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::SessionNotFound(static_cast< const FIX::SessionNotFound& >(_e))),SWIGTYPE_p_FIX__SessionNotFound,SWIG_POINTER_OWN), "FIX::SessionNotFound", SWIGTYPE_p_FIX__SessionNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_sendToTarget__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 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 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Session_sendToTarget",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "1"" of type '" "FIX::Message &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(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 '" "Session_sendToTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', 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 '" "Session_sendToTarget" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_sendToTarget" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)FIX::Session::sendToTarget(*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::SessionNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::SessionNotFound(static_cast< const FIX::SessionNotFound& >(_e))),SWIGTYPE_p_FIX__SessionNotFound,SWIG_POINTER_OWN), "FIX::SessionNotFound", SWIGTYPE_p_FIX__SessionNotFound); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  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_Session_sendToTarget(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Session_sendToTarget__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Session_sendToTarget__SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 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_Session_sendToTarget__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SenderCompID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__TargetCompID, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Session_sendToTarget__SWIG_4(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 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_Session_sendToTarget__SWIG_6(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SenderCompID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__TargetCompID, 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_Session_sendToTarget__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Message, 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_Session_sendToTarget__SWIG_5(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Session_sendToTarget'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Session::sendToTarget(FIX::Message &,std::string const &)\n"
    "    FIX::Session::sendToTarget(FIX::Message &)\n"
    "    FIX::Session::sendToTarget(FIX::Message &,FIX::SessionID const &)\n"
    "    FIX::Session::sendToTarget(FIX::Message &,FIX::SenderCompID const &,FIX::TargetCompID const &,std::string const &)\n"
    "    FIX::Session::sendToTarget(FIX::Message &,FIX::SenderCompID const &,FIX::TargetCompID const &)\n"
    "    FIX::Session::sendToTarget(FIX::Message &,std::string const &,std::string const &,std::string const &)\n"
    "    FIX::Session::sendToTarget(FIX::Message &,std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Session_getSessions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::set< FIX::SessionID > > result;
  
  if (!PyArg_ParseTuple(args,(char *)":Session_getSessions")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = FIX::Session::getSessions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new std::set< FIX::SessionID >(static_cast< const std::set< FIX::SessionID >& >(result))), SWIGTYPE_p_std__setT_FIX__SessionID_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_doesSessionExist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_doesSessionExist",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_doesSessionExist" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_doesSessionExist" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::Session::doesSessionExist((FIX::SessionID const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_lookupSession__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Session *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_lookupSession",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_lookupSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_lookupSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Session *)FIX::Session::lookupSession((FIX::SessionID const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_lookupSession__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::Session *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Session_lookupSession",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_lookupSession" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_lookupSession" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_lookupSession" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Session *)FIX::Session::lookupSession((std::string const &)*arg1,arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_lookupSession__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::Session *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_lookupSession",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_lookupSession" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_lookupSession" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Session *)FIX::Session::lookupSession((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_lookupSession(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__SessionID, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Session_lookupSession__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_Session_lookupSession__SWIG_2(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_Session_lookupSession__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Session_lookupSession'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Session::lookupSession(FIX::SessionID const &)\n"
    "    FIX::Session::lookupSession(std::string const &,bool)\n"
    "    FIX::Session::lookupSession(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Session_isSessionRegistered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_isSessionRegistered",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_isSessionRegistered" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_isSessionRegistered" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)FIX::Session::isSessionRegistered((FIX::SessionID const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_registerSession(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Session *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_registerSession",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_registerSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_registerSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Session *)FIX::Session::registerSession((FIX::SessionID const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_unregisterSession(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_unregisterSession",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_unregisterSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_unregisterSession" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    FIX::Session::unregisterSession((FIX::SessionID const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_numSessions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)":Session_numSessions")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)FIX::Session::numSessions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isSessionTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  UtcTimeStamp *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:Session_isSessionTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_isSessionTime" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_isSessionTime" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_isSessionTime" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->isSessionTime((UtcTimeStamp const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isLogonTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  UtcTimeStamp *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:Session_isLogonTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_isLogonTime" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_isLogonTime" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_isLogonTime" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->isLogonTime((UtcTimeStamp const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isInitiator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_isInitiator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_isInitiator" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->isInitiator();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_isAcceptor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_isAcceptor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_isAcceptor" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->isAcceptor();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getLogonTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  TimeRange *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getLogonTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getLogonTime" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (TimeRange *) &(arg1)->getLogonTime();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeRange, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setLogonTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  TimeRange *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:Session_setLogonTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setLogonTime" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_TimeRange,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_setLogonTime" "', argument " "2"" of type '" "TimeRange const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_setLogonTime" "', argument " "2"" of type '" "TimeRange const &""'"); 
  }
  arg2 = reinterpret_cast< TimeRange * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setLogonTime((TimeRange const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getSenderDefaultApplVerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getSenderDefaultApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getSenderDefaultApplVerID" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &(arg1)->getSenderDefaultApplVerID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setSenderDefaultApplVerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setSenderDefaultApplVerID",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setSenderDefaultApplVerID" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(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 '" "Session_setSenderDefaultApplVerID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_setSenderDefaultApplVerID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setSenderDefaultApplVerID((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getTargetDefaultApplVerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getTargetDefaultApplVerID",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getTargetDefaultApplVerID" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::string *) &(arg1)->getTargetDefaultApplVerID();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setTargetDefaultApplVerID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setTargetDefaultApplVerID",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setTargetDefaultApplVerID" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(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 '" "Session_setTargetDefaultApplVerID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_setTargetDefaultApplVerID" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setTargetDefaultApplVerID((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getSendRedundantResendRequests(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getSendRedundantResendRequests",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getSendRedundantResendRequests" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->getSendRedundantResendRequests();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setSendRedundantResendRequests(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setSendRedundantResendRequests",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setSendRedundantResendRequests" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setSendRedundantResendRequests" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setSendRedundantResendRequests(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getCheckCompId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getCheckCompId",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getCheckCompId" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->getCheckCompId();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setCheckCompId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setCheckCompId",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setCheckCompId" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setCheckCompId" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setCheckCompId(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getCheckLatency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getCheckLatency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getCheckLatency" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->getCheckLatency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setCheckLatency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setCheckLatency",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setCheckLatency" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setCheckLatency" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setCheckLatency(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getMaxLatency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getMaxLatency",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getMaxLatency" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)(arg1)->getMaxLatency();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setMaxLatency(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setMaxLatency",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setMaxLatency" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setMaxLatency" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setMaxLatency(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getLogonTimeout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getLogonTimeout",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getLogonTimeout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)(arg1)->getLogonTimeout();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setLogonTimeout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setLogonTimeout",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setLogonTimeout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setLogonTimeout" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setLogonTimeout(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getLogoutTimeout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getLogoutTimeout",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getLogoutTimeout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)(arg1)->getLogoutTimeout();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setLogoutTimeout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setLogoutTimeout",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setLogoutTimeout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setLogoutTimeout" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setLogoutTimeout(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getResetOnLogon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getResetOnLogon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getResetOnLogon" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->getResetOnLogon();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setResetOnLogon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setResetOnLogon",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setResetOnLogon" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setResetOnLogon" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setResetOnLogon(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getResetOnLogout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getResetOnLogout",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getResetOnLogout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->getResetOnLogout();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setResetOnLogout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setResetOnLogout",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setResetOnLogout" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setResetOnLogout" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setResetOnLogout(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getResetOnDisconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getResetOnDisconnect",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getResetOnDisconnect" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->getResetOnDisconnect();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setResetOnDisconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setResetOnDisconnect",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setResetOnDisconnect" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setResetOnDisconnect" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setResetOnDisconnect(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getRefreshOnLogon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getRefreshOnLogon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getRefreshOnLogon" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->getRefreshOnLogon();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setRefreshOnLogon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setRefreshOnLogon",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setRefreshOnLogon" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setRefreshOnLogon" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setRefreshOnLogon(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getMillisecondsInTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getMillisecondsInTimeStamp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getMillisecondsInTimeStamp" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->getMillisecondsInTimeStamp();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setMillisecondsInTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setMillisecondsInTimeStamp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setMillisecondsInTimeStamp" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setMillisecondsInTimeStamp" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setMillisecondsInTimeStamp(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getPersistMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getPersistMessages",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getPersistMessages" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->getPersistMessages();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setPersistMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setPersistMessages",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setPersistMessages" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setPersistMessages" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setPersistMessages(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getValidateLengthAndChecksum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getValidateLengthAndChecksum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getValidateLengthAndChecksum" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->getValidateLengthAndChecksum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setValidateLengthAndChecksum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 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:Session_setValidateLengthAndChecksum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setValidateLengthAndChecksum" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Session_setValidateLengthAndChecksum" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setValidateLengthAndChecksum(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_setResponder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  Responder *arg2 = (Responder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Session_setResponder",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_setResponder" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Responder, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_setResponder" "', argument " "2"" of type '" "Responder *""'"); 
  }
  arg2 = reinterpret_cast< Responder * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setResponder(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_send(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::Message *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:Session_send",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_send" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_send" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_send" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->send(*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_next__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_next",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_next" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->next();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_next__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  UtcTimeStamp *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:Session_next",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_next" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_next" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_next" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->next((UtcTimeStamp const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_next__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  std::string *arg2 = 0 ;
  UtcTimeStamp *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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:Session_next",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_next" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(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 '" "Session_next" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_next" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Session_next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  arg3 = reinterpret_cast< UtcTimeStamp * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Session_next" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->next((std::string const &)*arg2,(UtcTimeStamp const &)*arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_next__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  std::string *arg2 = 0 ;
  UtcTimeStamp *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:Session_next",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_next" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(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 '" "Session_next" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_next" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Session_next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  arg3 = reinterpret_cast< UtcTimeStamp * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->next((std::string const &)*arg2,(UtcTimeStamp const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_next__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::Message *arg2 = 0 ;
  UtcTimeStamp *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:Session_next",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_next" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Message,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_next" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_next" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Session_next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  arg3 = reinterpret_cast< UtcTimeStamp * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Session_next" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->next((FIX::Message const &)*arg2,(UtcTimeStamp const &)*arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_next__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  FIX::Message *arg2 = 0 ;
  UtcTimeStamp *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:Session_next",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_next" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Message,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Session_next" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_next" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Session_next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Session_next" "', argument " "3"" of type '" "UtcTimeStamp const &""'"); 
  }
  arg3 = reinterpret_cast< UtcTimeStamp * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->next((FIX::Message const &)*arg2,(UtcTimeStamp const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_next(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Session_next__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_UtcTimeStamp, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Session_next__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__Message, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_UtcTimeStamp, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Session_next__SWIG_5(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 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_UtcTimeStamp, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Session_next__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__Message, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_UtcTimeStamp, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Session_next__SWIG_4(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Session, 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_UtcTimeStamp, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Session_next__SWIG_2(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Session_next'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Session::next()\n"
    "    FIX::Session::next(UtcTimeStamp const &)\n"
    "    FIX::Session::next(std::string const &,UtcTimeStamp const &,bool)\n"
    "    FIX::Session::next(std::string const &,UtcTimeStamp const &)\n"
    "    FIX::Session::next(FIX::Message const &,UtcTimeStamp const &,bool)\n"
    "    FIX::Session::next(FIX::Message const &,UtcTimeStamp const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Session_disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_disconnect",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_disconnect" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->disconnect();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getExpectedSenderNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getExpectedSenderNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getExpectedSenderNum" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (long)(arg1)->getExpectedSenderNum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getExpectedTargetNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getExpectedTargetNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getExpectedTargetNum" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (long)(arg1)->getExpectedTargetNum();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Log *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getLog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getLog" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (Log *)(arg1)->getLog();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Log, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Session_getStore(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Session *arg1 = (FIX::Session *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  MessageStore *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Session_getStore",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Session, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Session_getStore" "', argument " "1"" of type '" "FIX::Session *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Session * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (MessageStore *)(arg1)->getStore();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MessageStore, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Session_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Session, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_LogFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LogFactory *arg1 = (FIX::LogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LogFactory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LogFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogFactory" "', argument " "1"" of type '" "FIX::LogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LogFactory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogFactory_create__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LogFactory *arg1 = (FIX::LogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Log *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LogFactory_create",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogFactory_create" "', argument " "1"" of type '" "FIX::LogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LogFactory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Log *)(arg1)->create();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogFactory_create__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LogFactory *arg1 = (FIX::LogFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::Log *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LogFactory_create",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogFactory_create" "', argument " "1"" of type '" "FIX::LogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Log *)(arg1)->create((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LogFactory_create(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__LogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LogFactory_create__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__LogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LogFactory_create__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LogFactory_create'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::LogFactory::create()\n"
    "    FIX::LogFactory::create(FIX::SessionID const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LogFactory_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::LogFactory *arg1 = (FIX::LogFactory *) 0 ;
  FIX::Log *arg2 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LogFactory_destroy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__LogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogFactory_destroy" "', argument " "1"" of type '" "FIX::LogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::LogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogFactory_destroy" "', argument " "2"" of type '" "FIX::Log *""'"); 
  }
  arg2 = reinterpret_cast< FIX::Log * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->destroy(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LogFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__LogFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ScreenLogFactory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::ScreenLogFactory *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ScreenLogFactory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScreenLogFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScreenLogFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ScreenLogFactory *)new FIX::ScreenLogFactory((FIX::SessionSettings const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ScreenLogFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScreenLogFactory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  FIX::ScreenLogFactory *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ScreenLogFactory",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScreenLogFactory" "', 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_ScreenLogFactory" "', 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 '" "new_ScreenLogFactory" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ScreenLogFactory *)new FIX::ScreenLogFactory(arg1,arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ScreenLogFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScreenLogFactory(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ScreenLogFactory__SWIG_0(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_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_new_ScreenLogFactory__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ScreenLogFactory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ScreenLogFactory::ScreenLogFactory(FIX::SessionSettings const &)\n"
    "    FIX::ScreenLogFactory::ScreenLogFactory(bool,bool,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ScreenLogFactory_create__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLogFactory *arg1 = (FIX::ScreenLogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Log *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ScreenLogFactory_create",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ScreenLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenLogFactory_create" "', argument " "1"" of type '" "FIX::ScreenLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLogFactory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Log *)(arg1)->create();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLogFactory_create__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLogFactory *arg1 = (FIX::ScreenLogFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::Log *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ScreenLogFactory_create",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ScreenLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenLogFactory_create" "', argument " "1"" of type '" "FIX::ScreenLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScreenLogFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScreenLogFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Log *)(arg1)->create((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLogFactory_create(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__ScreenLogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ScreenLogFactory_create__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__ScreenLogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ScreenLogFactory_create__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ScreenLogFactory_create'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ScreenLogFactory::create()\n"
    "    FIX::ScreenLogFactory::create(FIX::SessionID const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ScreenLogFactory_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLogFactory *arg1 = (FIX::ScreenLogFactory *) 0 ;
  FIX::Log *arg2 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ScreenLogFactory_destroy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ScreenLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenLogFactory_destroy" "', argument " "1"" of type '" "FIX::ScreenLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScreenLogFactory_destroy" "', argument " "2"" of type '" "FIX::Log *""'"); 
  }
  arg2 = reinterpret_cast< FIX::Log * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->destroy(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScreenLogFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLogFactory *arg1 = (FIX::ScreenLogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ScreenLogFactory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ScreenLogFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScreenLogFactory" "', argument " "1"" of type '" "FIX::ScreenLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLogFactory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScreenLogFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ScreenLogFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Log *arg1 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Log",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Log, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', argument " "1"" of type '" "FIX::Log *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Log * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Log_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Log *arg1 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Log_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_clear" "', argument " "1"" of type '" "FIX::Log *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Log * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Log_backup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Log *arg1 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Log_backup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_backup" "', argument " "1"" of type '" "FIX::Log *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Log * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->backup();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Log_onIncoming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Log *arg1 = (FIX::Log *) 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:Log_onIncoming",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_onIncoming" "', argument " "1"" of type '" "FIX::Log *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Log * >(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 '" "Log_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Log_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onIncoming((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Log_onOutgoing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Log *arg1 = (FIX::Log *) 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:Log_onOutgoing",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_onOutgoing" "', argument " "1"" of type '" "FIX::Log *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Log * >(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 '" "Log_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Log_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onOutgoing((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Log_onEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Log *arg1 = (FIX::Log *) 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:Log_onEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_onEvent" "', argument " "1"" of type '" "FIX::Log *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Log * >(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 '" "Log_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Log_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onEvent((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Log, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_NullLog_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullLog *arg1 = (FIX::NullLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:NullLog_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NullLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullLog_clear" "', argument " "1"" of type '" "FIX::NullLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullLog * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullLog_backup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullLog *arg1 = (FIX::NullLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:NullLog_backup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NullLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullLog_backup" "', argument " "1"" of type '" "FIX::NullLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullLog * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->backup();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullLog_onIncoming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullLog *arg1 = (FIX::NullLog *) 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:NullLog_onIncoming",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NullLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullLog_onIncoming" "', argument " "1"" of type '" "FIX::NullLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullLog * >(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 '" "NullLog_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NullLog_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onIncoming((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullLog_onOutgoing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullLog *arg1 = (FIX::NullLog *) 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:NullLog_onOutgoing",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NullLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullLog_onOutgoing" "', argument " "1"" of type '" "FIX::NullLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullLog * >(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 '" "NullLog_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NullLog_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onOutgoing((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_NullLog_onEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullLog *arg1 = (FIX::NullLog *) 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:NullLog_onEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NullLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NullLog_onEvent" "', argument " "1"" of type '" "FIX::NullLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullLog * >(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 '" "NullLog_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NullLog_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onEvent((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NullLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullLog *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NullLog")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NullLog *)new FIX::NullLog();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NullLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NullLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullLog *arg1 = (FIX::NullLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NullLog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NullLog, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NullLog" "', argument " "1"" of type '" "FIX::NullLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullLog * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NullLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NullLog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ScreenLog__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  FIX::ScreenLog *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ScreenLog",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScreenLog" "', 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_ScreenLog" "', 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 '" "new_ScreenLog" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ScreenLog *)new FIX::ScreenLog(arg1,arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ScreenLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScreenLog__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionID *arg1 = 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 ;
  FIX::ScreenLog *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ScreenLog",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScreenLog" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScreenLog" "', argument " "1"" of type '" "FIX::SessionID const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionID * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScreenLog" "', 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 '" "new_ScreenLog" "', 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_ScreenLog" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::ScreenLog *)new FIX::ScreenLog((FIX::SessionID const &)*arg1,arg2,arg3,arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__ScreenLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ScreenLog(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_bool(argv[0], NULL);
      _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_new_ScreenLog__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__SessionID, 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_new_ScreenLog__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ScreenLog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::ScreenLog::ScreenLog(bool,bool,bool)\n"
    "    FIX::ScreenLog::ScreenLog(FIX::SessionID const &,bool,bool,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ScreenLog_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ScreenLog_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenLog_clear" "', argument " "1"" of type '" "FIX::ScreenLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLog_backup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ScreenLog_backup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenLog_backup" "', argument " "1"" of type '" "FIX::ScreenLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->backup();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLog_onIncoming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 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:ScreenLog_onIncoming",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenLog_onIncoming" "', argument " "1"" of type '" "FIX::ScreenLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(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 '" "ScreenLog_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScreenLog_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onIncoming((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLog_onOutgoing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 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:ScreenLog_onOutgoing",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenLog_onOutgoing" "', argument " "1"" of type '" "FIX::ScreenLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(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 '" "ScreenLog_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScreenLog_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onOutgoing((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLog_onEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 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:ScreenLog_onEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenLog_onEvent" "', argument " "1"" of type '" "FIX::ScreenLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(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 '" "ScreenLog_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScreenLog_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onEvent((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLog_getMillisecondsInTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ScreenLog_getMillisecondsInTimeStamp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenLog_getMillisecondsInTimeStamp" "', argument " "1"" of type '" "FIX::ScreenLog const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::ScreenLog const *)arg1)->getMillisecondsInTimeStamp();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ScreenLog_setMillisecondsInTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 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:ScreenLog_setMillisecondsInTimeStamp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ScreenLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScreenLog_setMillisecondsInTimeStamp" "', argument " "1"" of type '" "FIX::ScreenLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScreenLog_setMillisecondsInTimeStamp" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setMillisecondsInTimeStamp(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ScreenLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::ScreenLog *arg1 = (FIX::ScreenLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ScreenLog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__ScreenLog, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScreenLog" "', argument " "1"" of type '" "FIX::ScreenLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::ScreenLog * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ScreenLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__ScreenLog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FileLogFactory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FileLogFactory *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FileLogFactory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileLogFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileLogFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FileLogFactory *)new FIX::FileLogFactory((FIX::SessionSettings const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FileLogFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLogFactory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::FileLogFactory *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FileLogFactory",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileLogFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileLogFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FileLogFactory *)new FIX::FileLogFactory((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FileLogFactory, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLogFactory__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::FileLogFactory *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_FileLogFactory",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileLogFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileLogFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    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_FileLogFactory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileLogFactory" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FileLogFactory *)new FIX::FileLogFactory((std::string const &)*arg1,(std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FileLogFactory, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLogFactory(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileLogFactory__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_FileLogFactory__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_FileLogFactory__SWIG_2(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FileLogFactory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FileLogFactory::FileLogFactory(FIX::SessionSettings const &)\n"
    "    FIX::FileLogFactory::FileLogFactory(std::string const &)\n"
    "    FIX::FileLogFactory::FileLogFactory(std::string const &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FileLogFactory_create__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLogFactory *arg1 = (FIX::FileLogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Log *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FileLogFactory_create",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileLogFactory_create" "', argument " "1"" of type '" "FIX::FileLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileLogFactory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Log *)(arg1)->create();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLogFactory_create__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLogFactory *arg1 = (FIX::FileLogFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::Log *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FileLogFactory_create",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileLogFactory_create" "', argument " "1"" of type '" "FIX::FileLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileLogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileLogFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileLogFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Log *)(arg1)->create((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLogFactory_create(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__FileLogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FileLogFactory_create__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__FileLogFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FileLogFactory_create__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FileLogFactory_create'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FileLogFactory::create()\n"
    "    FIX::FileLogFactory::create(FIX::SessionID const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FileLogFactory_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLogFactory *arg1 = (FIX::FileLogFactory *) 0 ;
  FIX::Log *arg2 = (FIX::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FileLogFactory_destroy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileLogFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileLogFactory_destroy" "', argument " "1"" of type '" "FIX::FileLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileLogFactory * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FIX__Log, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileLogFactory_destroy" "', argument " "2"" of type '" "FIX::Log *""'"); 
  }
  arg2 = reinterpret_cast< FIX::Log * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->destroy(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FileLogFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLogFactory *arg1 = (FIX::FileLogFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FileLogFactory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileLogFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileLogFactory" "', argument " "1"" of type '" "FIX::FileLogFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileLogFactory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FileLogFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FileLogFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FileLog__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::FileLog *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FileLog",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FileLog *)new FIX::FileLog((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FileLog, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLog__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  FIX::SessionID *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::FileLog *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_FileLog",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FileLog" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileLog" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FileLog *)new FIX::FileLog((std::string const &)*arg1,(FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FileLog, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLog__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  FIX::SessionID *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  FIX::FileLog *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_FileLog",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileLog" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    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_FileLog" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileLog" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FileLog" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileLog" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FileLog *)new FIX::FileLog((std::string const &)*arg1,(std::string const &)*arg2,(FIX::SessionID const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FileLog, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileLog(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (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_new_FileLog__SWIG_0(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_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FileLog__SWIG_1(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_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionID, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FileLog__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FileLog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FileLog::FileLog(std::string const &)\n"
    "    FIX::FileLog::FileLog(std::string const &,FIX::SessionID const &)\n"
    "    FIX::FileLog::FileLog(std::string const &,std::string const &,FIX::SessionID const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_FileLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FileLog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileLog, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileLog" "', argument " "1"" of type '" "FIX::FileLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLog_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FileLog_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileLog_clear" "', argument " "1"" of type '" "FIX::FileLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->clear();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLog_backup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FileLog_backup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileLog_backup" "', argument " "1"" of type '" "FIX::FileLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->backup();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLog_onIncoming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLog *arg1 = (FIX::FileLog *) 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:FileLog_onIncoming",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileLog_onIncoming" "', argument " "1"" of type '" "FIX::FileLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(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 '" "FileLog_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileLog_onIncoming" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onIncoming((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLog_onOutgoing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLog *arg1 = (FIX::FileLog *) 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:FileLog_onOutgoing",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileLog_onOutgoing" "', argument " "1"" of type '" "FIX::FileLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(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 '" "FileLog_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileLog_onOutgoing" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onOutgoing((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLog_onEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLog *arg1 = (FIX::FileLog *) 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:FileLog_onEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileLog_onEvent" "', argument " "1"" of type '" "FIX::FileLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(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 '" "FileLog_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileLog_onEvent" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onEvent((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLog_getMillisecondsInTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLog *arg1 = (FIX::FileLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FileLog_getMillisecondsInTimeStamp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileLog_getMillisecondsInTimeStamp" "', argument " "1"" of type '" "FIX::FileLog const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::FileLog const *)arg1)->getMillisecondsInTimeStamp();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileLog_setMillisecondsInTimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileLog *arg1 = (FIX::FileLog *) 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:FileLog_setMillisecondsInTimeStamp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileLog_setMillisecondsInTimeStamp" "', argument " "1"" of type '" "FIX::FileLog *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileLog * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileLog_setMillisecondsInTimeStamp" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setMillisecondsInTimeStamp(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FileLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FileLog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_MessageStoreFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreFactory *arg1 = (FIX::MessageStoreFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MessageStoreFactory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageStoreFactory" "', argument " "1"" of type '" "FIX::MessageStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreFactory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreFactory_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreFactory *arg1 = (FIX::MessageStoreFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::MessageStore *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MessageStoreFactory_create",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreFactory_create" "', argument " "1"" of type '" "FIX::MessageStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStoreFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MessageStore *)(arg1)->create((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreFactory_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreFactory *arg1 = (FIX::MessageStoreFactory *) 0 ;
  FIX::MessageStore *arg2 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MessageStoreFactory_destroy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreFactory_destroy" "', argument " "1"" of type '" "FIX::MessageStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStoreFactory_destroy" "', argument " "2"" of type '" "FIX::MessageStore *""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStore * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->destroy(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MessageStoreFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MessageStoreFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_MemoryStoreFactory_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStoreFactory *arg1 = (FIX::MemoryStoreFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::MessageStore *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MemoryStoreFactory_create",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryStoreFactory_create" "', argument " "1"" of type '" "FIX::MemoryStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryStoreFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryStoreFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MessageStore *)(arg1)->create((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStoreFactory_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStoreFactory *arg1 = (FIX::MemoryStoreFactory *) 0 ;
  FIX::MessageStore *arg2 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MemoryStoreFactory_destroy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryStoreFactory_destroy" "', argument " "1"" of type '" "FIX::MemoryStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryStoreFactory_destroy" "', argument " "2"" of type '" "FIX::MessageStore *""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStore * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->destroy(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MemoryStoreFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStoreFactory *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MemoryStoreFactory")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MemoryStoreFactory *)new FIX::MemoryStoreFactory();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MemoryStoreFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MemoryStoreFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStoreFactory *arg1 = (FIX::MemoryStoreFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MemoryStoreFactory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStoreFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MemoryStoreFactory" "', argument " "1"" of type '" "FIX::MemoryStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStoreFactory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MemoryStoreFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MemoryStoreFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_MessageStore(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MessageStore",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStore, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageStore" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MessageStore_set",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStore_set" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStore_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(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 '" "MessageStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::string > *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:MessageStore_get",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStore_get" "', argument " "1"" of type '" "FIX::MessageStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStore_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageStore_get" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageStore_get" "', argument " "4"" of type '" "std::vector< std::string > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStore_get" "', argument " "4"" of type '" "std::vector< std::string > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      ((FIX::MessageStore const *)arg1)->get(arg2,arg3,*arg4);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_getNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MessageStore_getNextSenderMsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStore_getNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (int)((FIX::MessageStore const *)arg1)->getNextSenderMsgSeqNum();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_getNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MessageStore_getNextTargetMsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStore_getNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (int)((FIX::MessageStore const *)arg1)->getNextTargetMsgSeqNum();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_setNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 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:MessageStore_setNextSenderMsgSeqNum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStore_setNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStore_setNextSenderMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setNextSenderMsgSeqNum(arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_setNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 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:MessageStore_setNextTargetMsgSeqNum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStore_setNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStore_setNextTargetMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setNextTargetMsgSeqNum(arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_incrNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MessageStore_incrNextSenderMsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStore_incrNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->incrNextSenderMsgSeqNum();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_incrNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MessageStore_incrNextTargetMsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStore_incrNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->incrNextTargetMsgSeqNum();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_getCreationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  UtcTimeStamp result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MessageStore_getCreationTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStore_getCreationTime" "', argument " "1"" of type '" "FIX::MessageStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = ((FIX::MessageStore const *)arg1)->getCreationTime();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj((new UtcTimeStamp(static_cast< const UtcTimeStamp& >(result))), SWIGTYPE_p_UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MessageStore_reset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStore_reset" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->reset();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStore_refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MessageStore_refresh",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStore_refresh" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->refresh();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MessageStore_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MessageStore, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MemoryStore(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MemoryStore")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MemoryStore *)new FIX::MemoryStore();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MemoryStore, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MemoryStore_set",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryStore_set" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MemoryStore_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(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 '" "MemoryStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::string > *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:MemoryStore_get",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryStore_get" "', argument " "1"" of type '" "FIX::MemoryStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MemoryStore_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryStore_get" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MemoryStore_get" "', argument " "4"" of type '" "std::vector< std::string > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryStore_get" "', argument " "4"" of type '" "std::vector< std::string > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      ((FIX::MemoryStore const *)arg1)->get(arg2,arg3,*arg4);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_getNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MemoryStore_getNextSenderMsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryStore_getNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MemoryStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (int)((FIX::MemoryStore const *)arg1)->getNextSenderMsgSeqNum();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_getNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MemoryStore_getNextTargetMsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryStore_getNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MemoryStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (int)((FIX::MemoryStore const *)arg1)->getNextTargetMsgSeqNum();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_setNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 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:MemoryStore_setNextSenderMsgSeqNum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryStore_setNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MemoryStore_setNextSenderMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setNextSenderMsgSeqNum(arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_setNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 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:MemoryStore_setNextTargetMsgSeqNum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryStore_setNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MemoryStore_setNextTargetMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setNextTargetMsgSeqNum(arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_incrNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MemoryStore_incrNextSenderMsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryStore_incrNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->incrNextSenderMsgSeqNum();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_incrNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MemoryStore_incrNextTargetMsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryStore_incrNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->incrNextTargetMsgSeqNum();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_setCreationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  UtcTimeStamp *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:MemoryStore_setCreationTime",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryStore_setCreationTime" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_UtcTimeStamp,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryStore_setCreationTime" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryStore_setCreationTime" "', argument " "2"" of type '" "UtcTimeStamp const &""'"); 
  }
  arg2 = reinterpret_cast< UtcTimeStamp * >(argp2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setCreationTime((UtcTimeStamp const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_getCreationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  UtcTimeStamp result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MemoryStore_getCreationTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryStore_getCreationTime" "', argument " "1"" of type '" "FIX::MemoryStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = ((FIX::MemoryStore const *)arg1)->getCreationTime();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj((new UtcTimeStamp(static_cast< const UtcTimeStamp& >(result))), SWIGTYPE_p_UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MemoryStore_reset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryStore_reset" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->reset();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MemoryStore_refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MemoryStore_refresh",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryStore_refresh" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->refresh();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MemoryStore(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MemoryStore *arg1 = (FIX::MemoryStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MemoryStore",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MemoryStore, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MemoryStore" "', argument " "1"" of type '" "FIX::MemoryStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MemoryStore * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MemoryStore_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MemoryStore, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MessageStoreFactoryExceptionWrapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreFactory *arg1 = (FIX::MessageStoreFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MessageStoreFactoryExceptionWrapper *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MessageStoreFactoryExceptionWrapper",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MessageStoreFactoryExceptionWrapper" "', argument " "1"" of type '" "FIX::MessageStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreFactory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MessageStoreFactoryExceptionWrapper *)new FIX::MessageStoreFactoryExceptionWrapper(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStoreFactoryExceptionWrapper, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreFactoryExceptionWrapper_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreFactoryExceptionWrapper *arg1 = (FIX::MessageStoreFactoryExceptionWrapper *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  bool *arg3 = 0 ;
  FIX::ConfigError *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 ;
  FIX::MessageStore *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:MessageStoreFactoryExceptionWrapper_create",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreFactoryExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "1"" of type '" "FIX::MessageStoreFactoryExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreFactoryExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "3"" of type '" "bool &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "3"" of type '" "bool &""'"); 
  }
  arg3 = reinterpret_cast< bool * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_FIX__ConfigError,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "4"" of type '" "FIX::ConfigError &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreFactoryExceptionWrapper_create" "', argument " "4"" of type '" "FIX::ConfigError &""'"); 
  }
  arg4 = reinterpret_cast< FIX::ConfigError * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MessageStore *)(arg1)->create((FIX::SessionID const &)*arg2,*arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreFactoryExceptionWrapper_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreFactoryExceptionWrapper *arg1 = (FIX::MessageStoreFactoryExceptionWrapper *) 0 ;
  FIX::MessageStore *arg2 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MessageStoreFactoryExceptionWrapper_destroy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreFactoryExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreFactoryExceptionWrapper_destroy" "', argument " "1"" of type '" "FIX::MessageStoreFactoryExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreFactoryExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStoreFactoryExceptionWrapper_destroy" "', argument " "2"" of type '" "FIX::MessageStore *""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStore * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->destroy(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MessageStoreFactoryExceptionWrapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreFactoryExceptionWrapper *arg1 = (FIX::MessageStoreFactoryExceptionWrapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MessageStoreFactoryExceptionWrapper",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreFactoryExceptionWrapper, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageStoreFactoryExceptionWrapper" "', argument " "1"" of type '" "FIX::MessageStoreFactoryExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreFactoryExceptionWrapper * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MessageStoreFactoryExceptionWrapper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MessageStoreFactoryExceptionWrapper, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MessageStoreExceptionWrapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStore *arg1 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MessageStoreExceptionWrapper *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MessageStoreExceptionWrapper",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MessageStoreExceptionWrapper" "', argument " "1"" of type '" "FIX::MessageStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStore * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MessageStoreExceptionWrapper *)new FIX::MessageStoreExceptionWrapper(arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MessageStoreExceptionWrapper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MessageStoreExceptionWrapper",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageStoreExceptionWrapper" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  bool *arg4 = 0 ;
  FIX::IOException *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  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:MessageStoreExceptionWrapper_set",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreExceptionWrapper_set" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStoreExceptionWrapper_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(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 '" "MessageStoreExceptionWrapper_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageStoreExceptionWrapper_set" "', argument " "4"" of type '" "bool &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_set" "', argument " "4"" of type '" "bool &""'"); 
  }
  arg4 = reinterpret_cast< bool * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MessageStoreExceptionWrapper_set" "', argument " "5"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_set" "', argument " "5"" of type '" "FIX::IOException &""'"); 
  }
  arg5 = reinterpret_cast< FIX::IOException * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->set(arg2,(std::string const &)*arg3,*arg4,*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::string > *arg4 = 0 ;
  bool *arg5 = 0 ;
  FIX::IOException *arg6 = 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 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:MessageStoreExceptionWrapper_get",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreExceptionWrapper_get" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStoreExceptionWrapper_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageStoreExceptionWrapper_get" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageStoreExceptionWrapper_get" "', argument " "4"" of type '" "std::vector< std::string > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_get" "', argument " "4"" of type '" "std::vector< std::string > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MessageStoreExceptionWrapper_get" "', argument " "5"" of type '" "bool &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_get" "', argument " "5"" of type '" "bool &""'"); 
  }
  arg5 = reinterpret_cast< bool * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "MessageStoreExceptionWrapper_get" "', argument " "6"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_get" "', argument " "6"" of type '" "FIX::IOException &""'"); 
  }
  arg6 = reinterpret_cast< FIX::IOException * >(argp6);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    ((FIX::MessageStoreExceptionWrapper const *)arg1)->get(arg2,arg3,*arg4,*arg5,*arg6);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_getNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  bool *arg2 = 0 ;
  FIX::IOException *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:MessageStoreExceptionWrapper_getNextSenderMsgSeqNum",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreExceptionWrapper_getNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStoreExceptionWrapper_getNextSenderMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_getNextSenderMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MessageStoreExceptionWrapper_getNextSenderMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_getNextSenderMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::MessageStoreExceptionWrapper const *)arg1)->getNextSenderMsgSeqNum(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_getNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  bool *arg2 = 0 ;
  FIX::IOException *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:MessageStoreExceptionWrapper_getNextTargetMsgSeqNum",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreExceptionWrapper_getNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStoreExceptionWrapper_getNextTargetMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_getNextTargetMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MessageStoreExceptionWrapper_getNextTargetMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_getNextTargetMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (int)((FIX::MessageStoreExceptionWrapper const *)arg1)->getNextTargetMsgSeqNum(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_setNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  int arg2 ;
  bool *arg3 = 0 ;
  FIX::IOException *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:MessageStoreExceptionWrapper_setNextSenderMsgSeqNum",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreExceptionWrapper_setNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStoreExceptionWrapper_setNextSenderMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MessageStoreExceptionWrapper_setNextSenderMsgSeqNum" "', argument " "3"" of type '" "bool &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_setNextSenderMsgSeqNum" "', argument " "3"" of type '" "bool &""'"); 
  }
  arg3 = reinterpret_cast< bool * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageStoreExceptionWrapper_setNextSenderMsgSeqNum" "', argument " "4"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_setNextSenderMsgSeqNum" "', argument " "4"" of type '" "FIX::IOException &""'"); 
  }
  arg4 = reinterpret_cast< FIX::IOException * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setNextSenderMsgSeqNum(arg2,*arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_setNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  int arg2 ;
  bool *arg3 = 0 ;
  FIX::IOException *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:MessageStoreExceptionWrapper_setNextTargetMsgSeqNum",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreExceptionWrapper_setNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageStoreExceptionWrapper_setNextTargetMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MessageStoreExceptionWrapper_setNextTargetMsgSeqNum" "', argument " "3"" of type '" "bool &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_setNextTargetMsgSeqNum" "', argument " "3"" of type '" "bool &""'"); 
  }
  arg3 = reinterpret_cast< bool * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageStoreExceptionWrapper_setNextTargetMsgSeqNum" "', argument " "4"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_setNextTargetMsgSeqNum" "', argument " "4"" of type '" "FIX::IOException &""'"); 
  }
  arg4 = reinterpret_cast< FIX::IOException * >(argp4);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setNextTargetMsgSeqNum(arg2,*arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  bool *arg2 = 0 ;
  FIX::IOException *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:MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->incrNextSenderMsgSeqNum(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  bool *arg2 = 0 ;
  FIX::IOException *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:MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->incrNextTargetMsgSeqNum(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_getCreationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  bool *arg2 = 0 ;
  FIX::IOException *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 ;
  UtcTimeStamp result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MessageStoreExceptionWrapper_getCreationTime",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreExceptionWrapper_getCreationTime" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStoreExceptionWrapper_getCreationTime" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_getCreationTime" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MessageStoreExceptionWrapper_getCreationTime" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_getCreationTime" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (arg1)->getCreationTime(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new UtcTimeStamp(static_cast< const UtcTimeStamp& >(result))), SWIGTYPE_p_UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  bool *arg2 = 0 ;
  FIX::IOException *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:MessageStoreExceptionWrapper_reset",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreExceptionWrapper_reset" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStoreExceptionWrapper_reset" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_reset" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MessageStoreExceptionWrapper_reset" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_reset" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->reset(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MessageStoreExceptionWrapper_refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::MessageStoreExceptionWrapper *arg1 = (FIX::MessageStoreExceptionWrapper *) 0 ;
  bool *arg2 = 0 ;
  FIX::IOException *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:MessageStoreExceptionWrapper_refresh",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageStoreExceptionWrapper_refresh" "', argument " "1"" of type '" "FIX::MessageStoreExceptionWrapper *""'"); 
  }
  arg1 = reinterpret_cast< FIX::MessageStoreExceptionWrapper * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageStoreExceptionWrapper_refresh" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_refresh" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__IOException,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MessageStoreExceptionWrapper_refresh" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MessageStoreExceptionWrapper_refresh" "', argument " "3"" of type '" "FIX::IOException &""'"); 
  }
  arg3 = reinterpret_cast< FIX::IOException * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->refresh(*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MessageStoreExceptionWrapper_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__MessageStoreExceptionWrapper, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FileStoreFactory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SessionSettings *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::FileStoreFactory *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FileStoreFactory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileStoreFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileStoreFactory" "', argument " "1"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::SessionSettings * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FileStoreFactory *)new FIX::FileStoreFactory((FIX::SessionSettings const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FileStoreFactory, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileStoreFactory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::FileStoreFactory *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FileStoreFactory",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileStoreFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileStoreFactory" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FileStoreFactory *)new FIX::FileStoreFactory((std::string const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FileStoreFactory, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FileStoreFactory(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__SessionSettings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileStoreFactory__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_FileStoreFactory__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FileStoreFactory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::FileStoreFactory::FileStoreFactory(FIX::SessionSettings const &)\n"
    "    FIX::FileStoreFactory::FileStoreFactory(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FileStoreFactory_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStoreFactory *arg1 = (FIX::FileStoreFactory *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::MessageStore *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FileStoreFactory_create",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileStoreFactory_create" "', argument " "1"" of type '" "FIX::FileStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileStoreFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileStoreFactory_create" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MessageStore *)(arg1)->create((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStoreFactory_destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStoreFactory *arg1 = (FIX::FileStoreFactory *) 0 ;
  FIX::MessageStore *arg2 = (FIX::MessageStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FileStoreFactory_destroy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStoreFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileStoreFactory_destroy" "', argument " "1"" of type '" "FIX::FileStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStoreFactory * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FIX__MessageStore, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileStoreFactory_destroy" "', argument " "2"" of type '" "FIX::MessageStore *""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStore * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->destroy(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FileStoreFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStoreFactory *arg1 = (FIX::FileStoreFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FileStoreFactory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStoreFactory, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileStoreFactory" "', argument " "1"" of type '" "FIX::FileStoreFactory *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStoreFactory * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FileStoreFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FileStoreFactory, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FileStore(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::FileStore *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_FileStore",&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_FileStore" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FileStore" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileStore" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::FileStore *)new FIX::FileStore(arg1,(FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__FileStore, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FileStore(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FileStore",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStore, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileStore" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:FileStore_set",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileStore_set" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileStore_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(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 '" "FileStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileStore_set" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::string > *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:FileStore_get",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileStore_get" "', argument " "1"" of type '" "FIX::FileStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileStore_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileStore_get" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FileStore_get" "', argument " "4"" of type '" "std::vector< std::string > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileStore_get" "', argument " "4"" of type '" "std::vector< std::string > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::string > * >(argp4);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      ((FIX::FileStore const *)arg1)->get(arg2,arg3,*arg4);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_getNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FileStore_getNextSenderMsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileStore_getNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::FileStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (int)((FIX::FileStore const *)arg1)->getNextSenderMsgSeqNum();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_getNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FileStore_getNextTargetMsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileStore_getNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::FileStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (int)((FIX::FileStore const *)arg1)->getNextTargetMsgSeqNum();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_setNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 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:FileStore_setNextSenderMsgSeqNum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileStore_setNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileStore_setNextSenderMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setNextSenderMsgSeqNum(arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_setNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 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:FileStore_setNextTargetMsgSeqNum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileStore_setNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileStore_setNextTargetMsgSeqNum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->setNextTargetMsgSeqNum(arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_incrNextSenderMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FileStore_incrNextSenderMsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileStore_incrNextSenderMsgSeqNum" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->incrNextSenderMsgSeqNum();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_incrNextTargetMsgSeqNum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FileStore_incrNextTargetMsgSeqNum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileStore_incrNextTargetMsgSeqNum" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->incrNextTargetMsgSeqNum();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_getCreationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  UtcTimeStamp result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FileStore_getCreationTime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileStore_getCreationTime" "', argument " "1"" of type '" "FIX::FileStore const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = ((FIX::FileStore const *)arg1)->getCreationTime();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj((new UtcTimeStamp(static_cast< const UtcTimeStamp& >(result))), SWIGTYPE_p_UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FileStore_reset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileStore_reset" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->reset();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FileStore_refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::FileStore *arg1 = (FIX::FileStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FileStore_refresh",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__FileStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileStore_refresh" "', argument " "1"" of type '" "FIX::FileStore *""'"); 
  }
  arg1 = reinterpret_cast< FIX::FileStore * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->refresh();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::IOException &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IOException(static_cast< const FIX::IOException& >(_e))),SWIGTYPE_p_FIX__IOException,SWIG_POINTER_OWN), "FIX::IOException", SWIGTYPE_p_FIX__IOException); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FileStore_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__FileStore, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_Application(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Application",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Application, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Application" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Application_onCreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  FIX::SessionID *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:Application_onCreate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Application_onCreate" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Application_onCreate" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Application_onCreate" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("FIX::Application::onCreate");
    } else {
      (arg1)->onCreate((FIX::SessionID const &)*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Application_onLogon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  FIX::SessionID *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:Application_onLogon",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Application_onLogon" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Application_onLogon" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Application_onLogon" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("FIX::Application::onLogon");
    } else {
      (arg1)->onLogon((FIX::SessionID const &)*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Application_onLogout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  FIX::SessionID *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:Application_onLogout",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Application_onLogout" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Application_onLogout" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Application_onLogout" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("FIX::Application::onLogout");
    } else {
      (arg1)->onLogout((FIX::SessionID const &)*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Application_toAdmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *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;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Application_toAdmin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Application_toAdmin" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Application_toAdmin" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Application_toAdmin" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Application_toAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Application_toAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("FIX::Application::toAdmin");
    } else {
      (arg1)->toAdmin(*arg2,(FIX::SessionID const &)*arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Application_toApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *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;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Application_toApp",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Application_toApp" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Application_toApp" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Application_toApp" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Application_toApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Application_toApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    try {
      if (upcall) {
        Swig::DirectorPureVirtualException::raise("FIX::Application::toApp");
      } else {
        (arg1)->toApp(*arg2,(FIX::SessionID const &)*arg3);
      }
    }
    catch(FIX::DoNotSend &_e) {
      SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::DoNotSend(static_cast< const FIX::DoNotSend& >(_e))),SWIGTYPE_p_FIX__DoNotSend,SWIG_POINTER_OWN), "FIX::DoNotSend", SWIGTYPE_p_FIX__DoNotSend); SWIG_fail;
    }
    
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Application_fromAdmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *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;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Application_fromAdmin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Application_fromAdmin" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Message,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Application_fromAdmin" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Application_fromAdmin" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Application_fromAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Application_fromAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    try {
      if (upcall) {
        Swig::DirectorPureVirtualException::raise("FIX::Application::fromAdmin");
      } else {
        (arg1)->fromAdmin((FIX::Message const &)*arg2,(FIX::SessionID const &)*arg3);
      }
    }
    catch(FIX::FieldNotFound &_e) {
      SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
    }
    catch(FIX::IncorrectDataFormat &_e) {
      SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN), "FIX::IncorrectDataFormat", SWIGTYPE_p_FIX__IncorrectDataFormat); SWIG_fail;
    }
    catch(FIX::IncorrectTagValue &_e) {
      SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectTagValue(static_cast< const FIX::IncorrectTagValue& >(_e))),SWIGTYPE_p_FIX__IncorrectTagValue,SWIG_POINTER_OWN), "FIX::IncorrectTagValue", SWIGTYPE_p_FIX__IncorrectTagValue); SWIG_fail;
    }
    catch(FIX::RejectLogon &_e) {
      SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::RejectLogon(static_cast< const FIX::RejectLogon& >(_e))),SWIGTYPE_p_FIX__RejectLogon,SWIG_POINTER_OWN), "FIX::RejectLogon", SWIGTYPE_p_FIX__RejectLogon); SWIG_fail;
    }
    
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Application_fromApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *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;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Application_fromApp",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Application_fromApp" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Message,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Application_fromApp" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Application_fromApp" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Application_fromApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Application_fromApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    try {
      if (upcall) {
        Swig::DirectorPureVirtualException::raise("FIX::Application::fromApp");
      } else {
        (arg1)->fromApp((FIX::Message const &)*arg2,(FIX::SessionID const &)*arg3);
      }
    }
    catch(FIX::FieldNotFound &_e) {
      SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
    }
    catch(FIX::IncorrectDataFormat &_e) {
      SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN), "FIX::IncorrectDataFormat", SWIGTYPE_p_FIX__IncorrectDataFormat); SWIG_fail;
    }
    catch(FIX::IncorrectTagValue &_e) {
      SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectTagValue(static_cast< const FIX::IncorrectTagValue& >(_e))),SWIGTYPE_p_FIX__IncorrectTagValue,SWIG_POINTER_OWN), "FIX::IncorrectTagValue", SWIGTYPE_p_FIX__IncorrectTagValue); SWIG_fail;
    }
    catch(FIX::UnsupportedMessageType &_e) {
      SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::UnsupportedMessageType(static_cast< const FIX::UnsupportedMessageType& >(_e))),SWIGTYPE_p_FIX__UnsupportedMessageType,SWIG_POINTER_OWN), "FIX::UnsupportedMessageType", SWIGTYPE_p_FIX__UnsupportedMessageType); SWIG_fail;
    }
    
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Application(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  FIX::Application *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Application",&obj0)) SWIG_fail;
  arg1 = obj0;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if ( arg1 != Py_None ) {
      /* subclassed */
      result = (FIX::Application *)new SwigDirector_Application(arg1); 
    } else {
      SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
      SWIG_fail;
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Application, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_Application(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = (FIX::Application *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:disown_Application",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Application, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Application" "', argument " "1"" of type '" "FIX::Application *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    {
      Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
      if (director) director->swig_disown();
    }
    
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Application_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Application, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SynchronizedApplication(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::SynchronizedApplication *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SynchronizedApplication",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SynchronizedApplication" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SynchronizedApplication" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::SynchronizedApplication *)new FIX::SynchronizedApplication(*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SynchronizedApplication, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_onCreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::SessionID *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:SynchronizedApplication_onCreate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SynchronizedApplication_onCreate" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SynchronizedApplication_onCreate" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SynchronizedApplication_onCreate" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onCreate((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_onLogon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::SessionID *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:SynchronizedApplication_onLogon",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SynchronizedApplication_onLogon" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SynchronizedApplication_onLogon" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SynchronizedApplication_onLogon" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onLogon((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_onLogout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::SessionID *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:SynchronizedApplication_onLogout",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SynchronizedApplication_onLogout" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SynchronizedApplication_onLogout" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SynchronizedApplication_onLogout" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->onLogout((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_toAdmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *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:SynchronizedApplication_toAdmin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SynchronizedApplication_toAdmin" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SynchronizedApplication_toAdmin" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SynchronizedApplication_toAdmin" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SynchronizedApplication_toAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SynchronizedApplication_toAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->toAdmin(*arg2,(FIX::SessionID const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_toApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *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:SynchronizedApplication_toApp",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SynchronizedApplication_toApp" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SynchronizedApplication_toApp" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SynchronizedApplication_toApp" "', argument " "2"" of type '" "FIX::Message &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SynchronizedApplication_toApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SynchronizedApplication_toApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->toApp(*arg2,(FIX::SessionID const &)*arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::DoNotSend &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::DoNotSend(static_cast< const FIX::DoNotSend& >(_e))),SWIGTYPE_p_FIX__DoNotSend,SWIG_POINTER_OWN), "FIX::DoNotSend", SWIGTYPE_p_FIX__DoNotSend); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_fromAdmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *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:SynchronizedApplication_fromAdmin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SynchronizedApplication_fromAdmin" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Message,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SynchronizedApplication_fromAdmin" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SynchronizedApplication_fromAdmin" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SynchronizedApplication_fromAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SynchronizedApplication_fromAdmin" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->fromAdmin((FIX::Message const &)*arg2,(FIX::SessionID const &)*arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::FieldNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
  }
  catch(FIX::IncorrectDataFormat &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN), "FIX::IncorrectDataFormat", SWIGTYPE_p_FIX__IncorrectDataFormat); SWIG_fail;
  }
  catch(FIX::IncorrectTagValue &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectTagValue(static_cast< const FIX::IncorrectTagValue& >(_e))),SWIGTYPE_p_FIX__IncorrectTagValue,SWIG_POINTER_OWN), "FIX::IncorrectTagValue", SWIGTYPE_p_FIX__IncorrectTagValue); SWIG_fail;
  }
  catch(FIX::RejectLogon &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::RejectLogon(static_cast< const FIX::RejectLogon& >(_e))),SWIGTYPE_p_FIX__RejectLogon,SWIG_POINTER_OWN), "FIX::RejectLogon", SWIGTYPE_p_FIX__RejectLogon); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_fromApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *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:SynchronizedApplication_fromApp",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SynchronizedApplication_fromApp" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Message,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SynchronizedApplication_fromApp" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SynchronizedApplication_fromApp" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SynchronizedApplication_fromApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SynchronizedApplication_fromApp" "', argument " "3"" of type '" "FIX::SessionID const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->fromApp((FIX::Message const &)*arg2,(FIX::SessionID const &)*arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::FieldNotFound &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN), "FIX::FieldNotFound", SWIGTYPE_p_FIX__FieldNotFound); SWIG_fail;
  }
  catch(FIX::IncorrectDataFormat &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN), "FIX::IncorrectDataFormat", SWIGTYPE_p_FIX__IncorrectDataFormat); SWIG_fail;
  }
  catch(FIX::IncorrectTagValue &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::IncorrectTagValue(static_cast< const FIX::IncorrectTagValue& >(_e))),SWIGTYPE_p_FIX__IncorrectTagValue,SWIG_POINTER_OWN), "FIX::IncorrectTagValue", SWIGTYPE_p_FIX__IncorrectTagValue); SWIG_fail;
  }
  catch(FIX::UnsupportedMessageType &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::UnsupportedMessageType(static_cast< const FIX::UnsupportedMessageType& >(_e))),SWIGTYPE_p_FIX__UnsupportedMessageType,SWIG_POINTER_OWN), "FIX::UnsupportedMessageType", SWIGTYPE_p_FIX__UnsupportedMessageType); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_m_mutex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  Mutex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SynchronizedApplication_m_mutex_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SynchronizedApplication_m_mutex_set" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Mutex,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SynchronizedApplication_m_mutex_set" "', argument " "2"" of type '" "Mutex""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SynchronizedApplication_m_mutex_set" "', argument " "2"" of type '" "Mutex""'");
    } else {
      Mutex * temp = reinterpret_cast< Mutex * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->m_mutex = arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_m_mutex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Mutex result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SynchronizedApplication_m_mutex_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SynchronizedApplication_m_mutex_get" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result =  ((arg1)->m_mutex);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj((new Mutex(static_cast< const Mutex& >(result))), SWIGTYPE_p_Mutex, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_app(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  FIX::Application *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SynchronizedApplication_app",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SynchronizedApplication_app" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Application *) &(arg1)->app();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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_FIX__Application, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_m_app_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Application *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:SynchronizedApplication_m_app_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SynchronizedApplication_m_app_set" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SynchronizedApplication_m_app_set" "', argument " "2"" of type '" "FIX::Application &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SynchronizedApplication_m_app_set" "', argument " "2"" of type '" "FIX::Application &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Application * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    if (arg1) (arg1)->m_app = *arg2;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SynchronizedApplication_m_app_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Application *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SynchronizedApplication_m_app_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SynchronizedApplication_m_app_get" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Application *) &(FIX::Application &) ((arg1)->m_app);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Application, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SynchronizedApplication(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SynchronizedApplication",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SynchronizedApplication, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SynchronizedApplication" "', argument " "1"" of type '" "FIX::SynchronizedApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SynchronizedApplication_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SynchronizedApplication, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NullApplication(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullApplication *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NullApplication")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::NullApplication *)new FIX::NullApplication();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__NullApplication, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NullApplication(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::NullApplication *arg1 = (FIX::NullApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NullApplication",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__NullApplication, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NullApplication" "', argument " "1"" of type '" "FIX::NullApplication *""'"); 
  }
  arg1 = reinterpret_cast< FIX::NullApplication * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NullApplication_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__NullApplication, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_Initiator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Initiator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Initiator" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Initiator_start",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_start" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->start();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN), "FIX::RuntimeError", SWIGTYPE_p_FIX__RuntimeError); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_block(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Initiator_block",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_block" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->block();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN), "FIX::RuntimeError", SWIGTYPE_p_FIX__RuntimeError); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_poll__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 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:Initiator_poll",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_poll" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Initiator_poll" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)(arg1)->poll(arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN), "FIX::RuntimeError", SWIGTYPE_p_FIX__RuntimeError); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_poll__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Initiator_poll",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_poll" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)(arg1)->poll();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN), "FIX::RuntimeError", SWIGTYPE_p_FIX__RuntimeError); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_poll(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Initiator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Initiator_poll__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Initiator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Initiator_poll__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Initiator_poll'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Initiator::poll(double)\n"
    "    FIX::Initiator::poll()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Initiator_stop__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 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:Initiator_stop",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_stop" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Initiator_stop" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->stop(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_stop__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Initiator_stop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_stop" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->stop();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_stop(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Initiator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Initiator_stop__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Initiator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Initiator_stop__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Initiator_stop'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Initiator::stop(bool)\n"
    "    FIX::Initiator::stop()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Initiator_isLoggedOn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Initiator_isLoggedOn",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_isLoggedOn" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->isLoggedOn();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getSession__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  Responder *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 ;
  FIX::Session *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Initiator_getSession",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_getSession" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Initiator_getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Initiator_getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Responder,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Initiator_getSession" "', argument " "3"" of type '" "Responder &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Initiator_getSession" "', argument " "3"" of type '" "Responder &""'"); 
  }
  arg3 = reinterpret_cast< Responder * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Session *)(arg1)->getSession((FIX::SessionID const &)*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getSessions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::set< FIX::SessionID > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Initiator_getSessions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_getSessions" "', argument " "1"" of type '" "FIX::Initiator const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::set< FIX::SessionID > *) &((FIX::Initiator const *)arg1)->getSessions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getSession__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::Session *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Initiator_getSession",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_getSession" "', argument " "1"" of type '" "FIX::Initiator const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Initiator_getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Initiator_getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Session *)((FIX::Initiator const *)arg1)->getSession((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getSession(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Initiator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Initiator_getSession__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Initiator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Responder, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Initiator_getSession__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Initiator_getSession'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Initiator::getSession(FIX::SessionID const &,Responder &)\n"
    "    FIX::Initiator::getSession(FIX::SessionID const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Initiator_getSessionSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::Dictionary *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Initiator_getSessionSettings",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_getSessionSettings" "', argument " "1"" of type '" "FIX::Initiator const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Initiator_getSessionSettings" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Initiator_getSessionSettings" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Dictionary *)((FIX::Initiator const *)arg1)->getSessionSettings((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_has(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  FIX::SessionID *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:Initiator_has",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_has" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Initiator_has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Initiator_has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->has((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_isStopped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Initiator_isStopped",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_isStopped" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->isStopped();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getApplication(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  FIX::Application *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Initiator_getApplication",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_getApplication" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Application *) &(arg1)->getApplication();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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_FIX__Application, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getMessageStoreFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MessageStoreFactory *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Initiator_getMessageStoreFactory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_getMessageStoreFactory" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MessageStoreFactory *) &(arg1)->getMessageStoreFactory();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Initiator_getLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Initiator *arg1 = (FIX::Initiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Log *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Initiator_getLog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Initiator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Initiator_getLog" "', argument " "1"" of type '" "FIX::Initiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Initiator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Log *)(arg1)->getLog();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Initiator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Initiator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SocketInitiatorBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *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 ;
  FIX::SocketInitiator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_SocketInitiatorBase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SocketInitiatorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketInitiatorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SocketInitiatorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketInitiatorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SocketInitiatorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketInitiatorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::SocketInitiator *)new FIX::SocketInitiator(*arg1,*arg2,(FIX::SessionSettings const &)*arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketInitiator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketInitiatorBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *arg3 = 0 ;
  FIX::LogFactory *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 ;
  FIX::SocketInitiator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_SocketInitiatorBase",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SocketInitiatorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketInitiatorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SocketInitiatorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketInitiatorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SocketInitiatorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketInitiatorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_FIX__LogFactory,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SocketInitiatorBase" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketInitiatorBase" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  arg4 = reinterpret_cast< FIX::LogFactory * >(argp4);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::SocketInitiator *)new FIX::SocketInitiator(*arg1,*arg2,(FIX::SessionSettings const &)*arg3,*arg4);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketInitiator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketInitiatorBase(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Application, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SocketInitiatorBase__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__LogFactory, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SocketInitiatorBase__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SocketInitiatorBase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SocketInitiator::SocketInitiator(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &)\n"
    "    FIX::SocketInitiator::SocketInitiator(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &,FIX::LogFactory &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SocketInitiatorBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketInitiator *arg1 = (FIX::SocketInitiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SocketInitiatorBase",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SocketInitiator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SocketInitiatorBase" "', argument " "1"" of type '" "FIX::SocketInitiator *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SocketInitiator * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SocketInitiatorBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SocketInitiator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_Acceptor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Acceptor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Acceptor" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::Log *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Acceptor_getLog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_getLog" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Log *)(arg1)->getLog();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Log, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Acceptor_start",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_start" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->start();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN), "FIX::RuntimeError", SWIGTYPE_p_FIX__RuntimeError); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_block(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Acceptor_block",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_block" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->block();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN), "FIX::RuntimeError", SWIGTYPE_p_FIX__RuntimeError); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_poll__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 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:Acceptor_poll",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_poll" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Acceptor_poll" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)(arg1)->poll(arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN), "FIX::RuntimeError", SWIGTYPE_p_FIX__RuntimeError); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_poll__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Acceptor_poll",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_poll" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (bool)(arg1)->poll();
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  catch(FIX::RuntimeError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::RuntimeError(static_cast< const FIX::RuntimeError& >(_e))),SWIGTYPE_p_FIX__RuntimeError,SWIG_POINTER_OWN), "FIX::RuntimeError", SWIGTYPE_p_FIX__RuntimeError); SWIG_fail;
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_poll(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Acceptor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Acceptor_poll__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Acceptor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Acceptor_poll__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Acceptor_poll'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Acceptor::poll(double)\n"
    "    FIX::Acceptor::poll()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Acceptor_stop__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 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:Acceptor_stop",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_stop" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Acceptor_stop" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->stop(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_stop__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Acceptor_stop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_stop" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->stop();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_stop(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[3];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Acceptor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Acceptor_stop__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Acceptor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Acceptor_stop__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Acceptor_stop'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Acceptor::stop(bool)\n"
    "    FIX::Acceptor::stop()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Acceptor_isLoggedOn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Acceptor_isLoggedOn",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_isLoggedOn" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->isLoggedOn();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getSession__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  std::string *arg2 = 0 ;
  Responder *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 ;
  FIX::Session *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Acceptor_getSession",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_getSession" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(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 '" "Acceptor_getSession" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Acceptor_getSession" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Responder,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Acceptor_getSession" "', argument " "3"" of type '" "Responder &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Acceptor_getSession" "', argument " "3"" of type '" "Responder &""'"); 
  }
  arg3 = reinterpret_cast< Responder * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Session *)(arg1)->getSession((std::string const &)*arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getSessions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::set< FIX::SessionID > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Acceptor_getSessions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_getSessions" "', argument " "1"" of type '" "FIX::Acceptor const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (std::set< FIX::SessionID > *) &((FIX::Acceptor const *)arg1)->getSessions();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_FIX__SessionID_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getSession__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::Session *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Acceptor_getSession",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_getSession" "', argument " "1"" of type '" "FIX::Acceptor const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Acceptor_getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Acceptor_getSession" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Session *)((FIX::Acceptor const *)arg1)->getSession((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Session, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getSession(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Acceptor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__SessionID, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Acceptor_getSession__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Acceptor, 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_Responder, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Acceptor_getSession__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Acceptor_getSession'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::Acceptor::getSession(std::string const &,Responder &)\n"
    "    FIX::Acceptor::getSession(FIX::SessionID const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Acceptor_getSessionSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  FIX::Dictionary *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Acceptor_getSessionSettings",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_getSessionSettings" "', argument " "1"" of type '" "FIX::Acceptor const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Acceptor_getSessionSettings" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Acceptor_getSessionSettings" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Dictionary *)((FIX::Acceptor const *)arg1)->getSessionSettings((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Dictionary, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_has(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  FIX::SessionID *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:Acceptor_has",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_has" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__SessionID,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Acceptor_has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Acceptor_has" "', argument " "2"" of type '" "FIX::SessionID const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->has((FIX::SessionID const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_isStopped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Acceptor_isStopped",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_isStopped" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)(arg1)->isStopped();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getApplication(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  FIX::Application *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Acceptor_getApplication",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_getApplication" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::Application *) &(arg1)->getApplication();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  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_FIX__Application, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Acceptor_getMessageStoreFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Acceptor *arg1 = (FIX::Acceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::MessageStoreFactory *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Acceptor_getMessageStoreFactory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__Acceptor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Acceptor_getMessageStoreFactory" "', argument " "1"" of type '" "FIX::Acceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::Acceptor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::MessageStoreFactory *) &(arg1)->getMessageStoreFactory();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__MessageStoreFactory, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Acceptor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__Acceptor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SocketAcceptorBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *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 ;
  FIX::SocketAcceptor *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_SocketAcceptorBase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SocketAcceptorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketAcceptorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SocketAcceptorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketAcceptorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SocketAcceptorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketAcceptorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::SocketAcceptor *)new FIX::SocketAcceptor(*arg1,*arg2,(FIX::SessionSettings const &)*arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketAcceptor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketAcceptorBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Application *arg1 = 0 ;
  FIX::MessageStoreFactory *arg2 = 0 ;
  FIX::SessionSettings *arg3 = 0 ;
  FIX::LogFactory *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 ;
  FIX::SocketAcceptor *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_SocketAcceptorBase",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SocketAcceptorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketAcceptorBase" "', argument " "1"" of type '" "FIX::Application &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__MessageStoreFactory,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SocketAcceptorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketAcceptorBase" "', argument " "2"" of type '" "FIX::MessageStoreFactory &""'"); 
  }
  arg2 = reinterpret_cast< FIX::MessageStoreFactory * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__SessionSettings,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SocketAcceptorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketAcceptorBase" "', argument " "3"" of type '" "FIX::SessionSettings const &""'"); 
  }
  arg3 = reinterpret_cast< FIX::SessionSettings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_FIX__LogFactory,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_SocketAcceptorBase" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SocketAcceptorBase" "', argument " "4"" of type '" "FIX::LogFactory &""'"); 
  }
  arg4 = reinterpret_cast< FIX::LogFactory * >(argp4);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::SocketAcceptor *)new FIX::SocketAcceptor(*arg1,*arg2,(FIX::SessionSettings const &)*arg3,*arg4);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__SocketAcceptor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SocketAcceptorBase(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[5];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__Application, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SocketAcceptorBase__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__Application, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__MessageStoreFactory, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_FIX__SessionSettings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__LogFactory, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_SocketAcceptorBase__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SocketAcceptorBase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::SocketAcceptor::SocketAcceptor(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &)\n"
    "    FIX::SocketAcceptor::SocketAcceptor(FIX::Application &,FIX::MessageStoreFactory &,FIX::SessionSettings const &,FIX::LogFactory &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SocketAcceptorBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::SocketAcceptor *arg1 = (FIX::SocketAcceptor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SocketAcceptorBase",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__SocketAcceptor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SocketAcceptorBase" "', argument " "1"" of type '" "FIX::SocketAcceptor *""'"); 
  }
  arg1 = reinterpret_cast< FIX::SocketAcceptor * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SocketAcceptorBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__SocketAcceptor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DataDictionary__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DataDictionary")) SWIG_fail;
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DataDictionary *)new FIX::DataDictionary();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionary__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DataDictionary *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DataDictionary",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataDictionary" "', argument " "1"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataDictionary" "', argument " "1"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (FIX::DataDictionary *)new FIX::DataDictionary((FIX::DataDictionary const &)*arg1);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionary__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  FIX::DataDictionary *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DataDictionary",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__istream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataDictionary" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataDictionary" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::DataDictionary *)new FIX::DataDictionary(*arg1);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionary__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  FIX::DataDictionary *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DataDictionary",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataDictionary" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataDictionary" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      result = (FIX::DataDictionary *)new FIX::DataDictionary((std::string const &)*arg1);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_NEW |  0 );
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg1->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DataDictionary(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[2];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_DataDictionary__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__DataDictionary, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DataDictionary__SWIG_1(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DataDictionary__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_DataDictionary__SWIG_3(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DataDictionary'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DataDictionary::DataDictionary()\n"
    "    FIX::DataDictionary::DataDictionary(FIX::DataDictionary const &)\n"
    "    FIX::DataDictionary::DataDictionary(std::istream &)\n"
    "    FIX::DataDictionary::DataDictionary(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DataDictionary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DataDictionary",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataDictionary" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    delete arg1;
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_readFromURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_readFromURL",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_readFromURL" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(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 '" "DataDictionary_readFromURL" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_readFromURL" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->readFromURL((std::string const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_readFromDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  DOMDocumentPtr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DataDictionary_readFromDocument",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_readFromDocument" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_DOMDocumentPtr,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataDictionary_readFromDocument" "', argument " "2"" of type '" "DOMDocumentPtr""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_readFromDocument" "', argument " "2"" of type '" "DOMDocumentPtr""'");
    } else {
      DOMDocumentPtr * temp = reinterpret_cast< DOMDocumentPtr * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->readFromDocument(arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_readFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::istream *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:DataDictionary_readFromStream",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_readFromStream" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataDictionary_readFromStream" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_readFromStream" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      (arg1)->readFromStream(*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::ConfigError &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::ConfigError(static_cast< const FIX::ConfigError& >(_e))),SWIGTYPE_p_FIX__ConfigError,SWIG_POINTER_OWN), "FIX::ConfigError", SWIGTYPE_p_FIX__ConfigError); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getOrderedFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  message_order *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DataDictionary_getOrderedFields",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_getOrderedFields" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (message_order *) &((FIX::DataDictionary const *)arg1)->getOrderedFields();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_message_order, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_setVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_setVersion",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_setVersion" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(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 '" "DataDictionary_setVersion" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_setVersion" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->setVersion((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DataDictionary_getVersion",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_getVersion" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = ((FIX::DataDictionary const *)arg1)->getVersion();
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_addField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_addField" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_addField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addField(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addFieldName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DataDictionary_addFieldName",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_addFieldName" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_addFieldName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(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 '" "DataDictionary_addFieldName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_addFieldName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addFieldName(arg2,(std::string const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getFieldName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::string temp3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DataDictionary_getFieldName",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_getFieldName" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_getFieldName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    temp3 = std::string((char*)PyString_AsString(obj2));
    arg3 = &temp3;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->getFieldName(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getFieldTag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string arg2 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int temp3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DataDictionary_getFieldTag",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_getFieldTag" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(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 '" "DataDictionary_getFieldTag" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    SWIG_AsVal_int(obj2, &temp3); 	 
    arg3 = &temp3;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->getFieldTag(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("int &") == "int &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyInt_FromLong(*arg3) ); 	 
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addValueName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:DataDictionary_addValueName",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_addValueName" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_addValueName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(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 '" "DataDictionary_addValueName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_addValueName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "DataDictionary_addValueName" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_addValueName" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addValueName(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getValueName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  std::string temp4 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:DataDictionary_getValueName",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_getValueName" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_getValueName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(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 '" "DataDictionary_getValueName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_getValueName" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    temp4 = std::string((char*)PyString_AsString(obj3));
    arg4 = &temp4;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->getValueName(arg2,(std::string const &)*arg3,*arg4);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  {
    if( std::string("std::string &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg4->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_isField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_isField" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_isField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->isField(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addMsgType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_addMsgType",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_addMsgType" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(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 '" "DataDictionary_addMsgType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_addMsgType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addMsgType((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isMsgType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_isMsgType",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_isMsgType" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(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 '" "DataDictionary_isMsgType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_isMsgType" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->isMsgType((std::string const &)*arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addMsgField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DataDictionary_addMsgField",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_addMsgField" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(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 '" "DataDictionary_addMsgField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_addMsgField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataDictionary_addMsgField" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addMsgField((std::string const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isMsgField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DataDictionary_isMsgField",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_isMsgField" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(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 '" "DataDictionary_isMsgField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_isMsgField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataDictionary_isMsgField" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->isMsgField((std::string const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addHeaderField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_addHeaderField",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_addHeaderField" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_addHeaderField" "', 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 '" "DataDictionary_addHeaderField" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addHeaderField(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isHeaderField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_isHeaderField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_isHeaderField" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_isHeaderField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->isHeaderField(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addTrailerField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_addTrailerField",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_addTrailerField" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_addTrailerField" "', 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 '" "DataDictionary_addTrailerField" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addTrailerField(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isTrailerField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_isTrailerField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_isTrailerField" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_isTrailerField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->isTrailerField(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addFieldType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  FIX::TYPE::Type 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:DataDictionary_addFieldType",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_addFieldType" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_addFieldType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__TYPE__Type,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DataDictionary_addFieldType" "', argument " "3"" of type '" "FIX::TYPE::Type""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_addFieldType" "', argument " "3"" of type '" "FIX::TYPE::Type""'");
    } else {
      FIX::TYPE::Type * temp = reinterpret_cast< FIX::TYPE::Type * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addFieldType(arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getFieldType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  FIX::TYPE::Type *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:DataDictionary_getFieldType",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_getFieldType" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_getFieldType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_FIX__TYPE__Type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DataDictionary_getFieldType" "', argument " "3"" of type '" "FIX::TYPE::Type &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_getFieldType" "', argument " "3"" of type '" "FIX::TYPE::Type &""'"); 
  }
  arg3 = reinterpret_cast< FIX::TYPE::Type * >(argp3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->getFieldType(arg2,*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addRequiredField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DataDictionary_addRequiredField",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_addRequiredField" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(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 '" "DataDictionary_addRequiredField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_addRequiredField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataDictionary_addRequiredField" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addRequiredField((std::string const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isRequiredField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DataDictionary_isRequiredField",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_isRequiredField" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(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 '" "DataDictionary_isRequiredField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_isRequiredField" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataDictionary_isRequiredField" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->isRequiredField((std::string const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addFieldValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DataDictionary_addFieldValue",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_addFieldValue" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_addFieldValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(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 '" "DataDictionary_addFieldValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_addFieldValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addFieldValue(arg2,(std::string const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_hasFieldValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_hasFieldValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_hasFieldValue" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_hasFieldValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->hasFieldValue(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isFieldValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DataDictionary_isFieldValue",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_isFieldValue" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_isFieldValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(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 '" "DataDictionary_isFieldValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_isFieldValue" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->isFieldValue(arg2,(std::string const &)*arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_addGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  FIX::DataDictionary *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:DataDictionary_addGroup",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_addGroup" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(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 '" "DataDictionary_addGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_addGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataDictionary_addGroup" "', 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 '" "DataDictionary_addGroup" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_FIX__DataDictionary,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DataDictionary_addGroup" "', argument " "5"" of type '" "FIX::DataDictionary const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_addGroup" "', argument " "5"" of type '" "FIX::DataDictionary const &""'"); 
  }
  arg5 = reinterpret_cast< FIX::DataDictionary * >(argp5);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->addGroup((std::string const &)*arg2,arg3,arg4,(FIX::DataDictionary const &)*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DataDictionary_isGroup",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_isGroup" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(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 '" "DataDictionary_isGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_isGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataDictionary_isGroup" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->isGroup((std::string const &)*arg2,arg3);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_getGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  int *arg4 = 0 ;
  FIX::DataDictionary **arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  int temp4 ;
  FIX::DataDictionary *temp5 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:DataDictionary_getGroup",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_getGroup" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(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 '" "DataDictionary_getGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_getGroup" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataDictionary_getGroup" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    SWIG_AsVal_int(obj3, &temp4); 	 
    arg4 = &temp4;
  }
  {
    arg5 = new FIX::DataDictionary*[1];
    *arg5 = temp5;
  }
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->getGroup((std::string const &)*arg2,arg3,*arg4,(FIX::DataDictionary const *&)*arg5);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyString_FromString(arg2->c_str()) );
    }
  }
  {
    if( std::string("int &") == "int &" )
    {
      if( !PyDict_Check(resultobj) )
      resultobj = PyDict_New();
      PyDict_SetItem( resultobj, PyInt_FromLong(PyDict_Size(resultobj)), PyInt_FromLong(*arg4) ); 	 
    }
  }
  {
    void* argp;
    FIX::DataDictionary* pDD = 0;
    int res = SWIG_ConvertPtr(obj4, &argp, SWIGTYPE_p_FIX__DataDictionary, 0 );
    pDD = reinterpret_cast< FIX::DataDictionary * >(argp);
    *pDD = *(*arg5);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isDataField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_isDataField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_isDataField" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_isDataField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->isDataField(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_isMultipleValueField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_isMultipleValueField",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_isMultipleValueField" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_isMultipleValueField" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    result = (bool)((FIX::DataDictionary const *)arg1)->isMultipleValueField(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_checkFieldsOutOfOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_checkFieldsOutOfOrder",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_checkFieldsOutOfOrder" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_checkFieldsOutOfOrder" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->checkFieldsOutOfOrder(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_checkFieldsHaveValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_checkFieldsHaveValues",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_checkFieldsHaveValues" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_checkFieldsHaveValues" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->checkFieldsHaveValues(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_checkUserDefinedFields(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 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:DataDictionary_checkUserDefinedFields",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_checkUserDefinedFields" "', argument " "1"" of type '" "FIX::DataDictionary *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataDictionary_checkUserDefinedFields" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    (arg1)->checkUserDefinedFields(arg2);
    SWIG_PYTHON_THREAD_END_ALLOW;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_validate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::Message *arg1 = 0 ;
  FIX::DataDictionary *arg2 = (FIX::DataDictionary *) (FIX::DataDictionary *)0 ;
  FIX::DataDictionary *arg3 = (FIX::DataDictionary *) (FIX::DataDictionary *)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:DataDictionary_validate",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_FIX__Message,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_validate" "', argument " "1"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_validate" "', argument " "1"" of type '" "FIX::Message const &""'"); 
  }
  arg1 = reinterpret_cast< FIX::Message * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataDictionary_validate" "', argument " "2"" of type '" "FIX::DataDictionary const *const""'"); 
  }
  arg2 = reinterpret_cast< FIX::DataDictionary * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DataDictionary_validate" "', argument " "3"" of type '" "FIX::DataDictionary const *const""'"); 
  }
  arg3 = reinterpret_cast< FIX::DataDictionary * >(argp3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      FIX::DataDictionary::validate((FIX::Message const &)*arg1,(FIX::DataDictionary const *)arg2,(FIX::DataDictionary const *)arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::Exception &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::Exception(static_cast< const FIX::Exception& >(_e))),SWIGTYPE_p_FIX__Exception,SWIG_POINTER_OWN), "FIX::Exception", SWIGTYPE_p_FIX__Exception); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_validate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  FIX::Message *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:DataDictionary_validate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_validate" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Message,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataDictionary_validate" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_validate" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      ((FIX::DataDictionary const *)arg1)->validate((FIX::Message const &)*arg2);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::Exception &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::Exception(static_cast< const FIX::Exception& >(_e))),SWIGTYPE_p_FIX__Exception,SWIG_POINTER_OWN), "FIX::Exception", SWIGTYPE_p_FIX__Exception); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_validate__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  FIX::DataDictionary *arg1 = (FIX::DataDictionary *) 0 ;
  FIX::Message *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:DataDictionary_validate",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FIX__DataDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataDictionary_validate" "', argument " "1"" of type '" "FIX::DataDictionary const *""'"); 
  }
  arg1 = reinterpret_cast< FIX::DataDictionary * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_FIX__Message,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataDictionary_validate" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataDictionary_validate" "', argument " "2"" of type '" "FIX::Message const &""'"); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataDictionary_validate" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  try {
    {
      SWIG_PYTHON_THREAD_BEGIN_ALLOW;
      ((FIX::DataDictionary const *)arg1)->validate((FIX::Message const &)*arg2,arg3);
      SWIG_PYTHON_THREAD_END_ALLOW;
    }
  }
  catch(FIX::Exception &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new FIX::Exception(static_cast< const FIX::Exception& >(_e))),SWIGTYPE_p_FIX__Exception,SWIG_POINTER_OWN), "FIX::Exception", SWIGTYPE_p_FIX__Exception); SWIG_fail;
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DataDictionary_validate(PyObject *self, PyObject *args) {
  int argc;
  PyObject *argv[4];
  int ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? (int)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_FIX__DataDictionary, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__Message, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DataDictionary_validate__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_FIX__Message, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DataDictionary_validate__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__DataDictionary, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_FIX__Message, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DataDictionary_validate__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DataDictionary_validate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    FIX::DataDictionary::validate(FIX::Message const &,FIX::DataDictionary const *const,FIX::DataDictionary const *const)\n"
    "    FIX::DataDictionary::validate(FIX::Message const &) const\n"
    "    FIX::DataDictionary::validate(FIX::Message const &,bool) const\n");
  return 0;
}


SWIGINTERN PyObject *DataDictionary_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_FIX__DataDictionary, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

static PyMethodDef SwigMethods[] = {
	 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { (char *)"new_IntArray", _wrap_new_IntArray, METH_VARARGS, NULL},
	 { (char *)"delete_IntArray", _wrap_delete_IntArray, METH_VARARGS, NULL},
	 { (char *)"IntArray___getitem__", _wrap_IntArray___getitem__, METH_VARARGS, NULL},
	 { (char *)"IntArray___setitem__", _wrap_IntArray___setitem__, METH_VARARGS, NULL},
	 { (char *)"IntArray_cast", _wrap_IntArray_cast, METH_VARARGS, NULL},
	 { (char *)"IntArray_frompointer", _wrap_IntArray_frompointer, METH_VARARGS, NULL},
	 { (char *)"IntArray_swigregister", IntArray_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Exception", _wrap_new_Exception, METH_VARARGS, NULL},
	 { (char *)"delete_Exception", _wrap_delete_Exception, METH_VARARGS, NULL},
	 { (char *)"Exception_type_set", _wrap_Exception_type_set, METH_VARARGS, NULL},
	 { (char *)"Exception_type_get", _wrap_Exception_type_get, METH_VARARGS, NULL},
	 { (char *)"Exception_detail_set", _wrap_Exception_detail_set, METH_VARARGS, NULL},
	 { (char *)"Exception_detail_get", _wrap_Exception_detail_get, METH_VARARGS, NULL},
	 { (char *)"Exception___str__", _wrap_Exception___str__, METH_VARARGS, NULL},
	 { (char *)"Exception_swigregister", Exception_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DataDictionaryNotFound", _wrap_new_DataDictionaryNotFound, METH_VARARGS, NULL},
	 { (char *)"delete_DataDictionaryNotFound", _wrap_delete_DataDictionaryNotFound, METH_VARARGS, NULL},
	 { (char *)"DataDictionaryNotFound_version_set", _wrap_DataDictionaryNotFound_version_set, METH_VARARGS, NULL},
	 { (char *)"DataDictionaryNotFound_version_get", _wrap_DataDictionaryNotFound_version_get, METH_VARARGS, NULL},
	 { (char *)"DataDictionaryNotFound_swigregister", DataDictionaryNotFound_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FieldNotFound", _wrap_new_FieldNotFound, METH_VARARGS, NULL},
	 { (char *)"FieldNotFound_field_set", _wrap_FieldNotFound_field_set, METH_VARARGS, NULL},
	 { (char *)"FieldNotFound_field_get", _wrap_FieldNotFound_field_get, METH_VARARGS, NULL},
	 { (char *)"delete_FieldNotFound", _wrap_delete_FieldNotFound, METH_VARARGS, NULL},
	 { (char *)"FieldNotFound_swigregister", FieldNotFound_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FieldConvertError", _wrap_new_FieldConvertError, METH_VARARGS, NULL},
	 { (char *)"delete_FieldConvertError", _wrap_delete_FieldConvertError, METH_VARARGS, NULL},
	 { (char *)"FieldConvertError_swigregister", FieldConvertError_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MessageParseError", _wrap_new_MessageParseError, METH_VARARGS, NULL},
	 { (char *)"delete_MessageParseError", _wrap_delete_MessageParseError, METH_VARARGS, NULL},
	 { (char *)"MessageParseError_swigregister", MessageParseError_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InvalidMessage", _wrap_new_InvalidMessage, METH_VARARGS, NULL},
	 { (char *)"delete_InvalidMessage", _wrap_delete_InvalidMessage, METH_VARARGS, NULL},
	 { (char *)"InvalidMessage_swigregister", InvalidMessage_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ConfigError", _wrap_new_ConfigError, METH_VARARGS, NULL},
	 { (char *)"delete_ConfigError", _wrap_delete_ConfigError, METH_VARARGS, NULL},
	 { (char *)"ConfigError_swigregister", ConfigError_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RuntimeError", _wrap_new_RuntimeError, METH_VARARGS, NULL},
	 { (char *)"delete_RuntimeError", _wrap_delete_RuntimeError, METH_VARARGS, NULL},
	 { (char *)"RuntimeError_swigregister", RuntimeError_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InvalidTagNumber", _wrap_new_InvalidTagNumber, METH_VARARGS, NULL},
	 { (char *)"InvalidTagNumber_field_set", _wrap_InvalidTagNumber_field_set, METH_VARARGS, NULL},
	 { (char *)"InvalidTagNumber_field_get", _wrap_InvalidTagNumber_field_get, METH_VARARGS, NULL},
	 { (char *)"delete_InvalidTagNumber", _wrap_delete_InvalidTagNumber, METH_VARARGS, NULL},
	 { (char *)"InvalidTagNumber_swigregister", InvalidTagNumber_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RequiredTagMissing", _wrap_new_RequiredTagMissing, METH_VARARGS, NULL},
	 { (char *)"RequiredTagMissing_field_set", _wrap_RequiredTagMissing_field_set, METH_VARARGS, NULL},
	 { (char *)"RequiredTagMissing_field_get", _wrap_RequiredTagMissing_field_get, METH_VARARGS, NULL},
	 { (char *)"delete_RequiredTagMissing", _wrap_delete_RequiredTagMissing, METH_VARARGS, NULL},
	 { (char *)"RequiredTagMissing_swigregister", RequiredTagMissing_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TagNotDefinedForMessage", _wrap_new_TagNotDefinedForMessage, METH_VARARGS, NULL},
	 { (char *)"TagNotDefinedForMessage_field_set", _wrap_TagNotDefinedForMessage_field_set, METH_VARARGS, NULL},
	 { (char *)"TagNotDefinedForMessage_field_get", _wrap_TagNotDefinedForMessage_field_get, METH_VARARGS, NULL},
	 { (char *)"delete_TagNotDefinedForMessage", _wrap_delete_TagNotDefinedForMessage, METH_VARARGS, NULL},
	 { (char *)"TagNotDefinedForMessage_swigregister", TagNotDefinedForMessage_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoTagValue", _wrap_new_NoTagValue, METH_VARARGS, NULL},
	 { (char *)"NoTagValue_field_set", _wrap_NoTagValue_field_set, METH_VARARGS, NULL},
	 { (char *)"NoTagValue_field_get", _wrap_NoTagValue_field_get, METH_VARARGS, NULL},
	 { (char *)"delete_NoTagValue", _wrap_delete_NoTagValue, METH_VARARGS, NULL},
	 { (char *)"NoTagValue_swigregister", NoTagValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IncorrectTagValue", _wrap_new_IncorrectTagValue, METH_VARARGS, NULL},
	 { (char *)"IncorrectTagValue_field_set", _wrap_IncorrectTagValue_field_set, METH_VARARGS, NULL},
	 { (char *)"IncorrectTagValue_field_get", _wrap_IncorrectTagValue_field_get, METH_VARARGS, NULL},
	 { (char *)"delete_IncorrectTagValue", _wrap_delete_IncorrectTagValue, METH_VARARGS, NULL},
	 { (char *)"IncorrectTagValue_swigregister", IncorrectTagValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IncorrectDataFormat", _wrap_new_IncorrectDataFormat, METH_VARARGS, NULL},
	 { (char *)"IncorrectDataFormat_field_set", _wrap_IncorrectDataFormat_field_set, METH_VARARGS, NULL},
	 { (char *)"IncorrectDataFormat_field_get", _wrap_IncorrectDataFormat_field_get, METH_VARARGS, NULL},
	 { (char *)"delete_IncorrectDataFormat", _wrap_delete_IncorrectDataFormat, METH_VARARGS, NULL},
	 { (char *)"IncorrectDataFormat_swigregister", IncorrectDataFormat_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IncorrectMessageStructure", _wrap_new_IncorrectMessageStructure, METH_VARARGS, NULL},
	 { (char *)"delete_IncorrectMessageStructure", _wrap_delete_IncorrectMessageStructure, METH_VARARGS, NULL},
	 { (char *)"IncorrectMessageStructure_swigregister", IncorrectMessageStructure_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DuplicateFieldNumber", _wrap_new_DuplicateFieldNumber, METH_VARARGS, NULL},
	 { (char *)"delete_DuplicateFieldNumber", _wrap_delete_DuplicateFieldNumber, METH_VARARGS, NULL},
	 { (char *)"DuplicateFieldNumber_swigregister", DuplicateFieldNumber_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InvalidMessageType", _wrap_new_InvalidMessageType, METH_VARARGS, NULL},
	 { (char *)"delete_InvalidMessageType", _wrap_delete_InvalidMessageType, METH_VARARGS, NULL},
	 { (char *)"InvalidMessageType_swigregister", InvalidMessageType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnsupportedMessageType", _wrap_new_UnsupportedMessageType, METH_VARARGS, NULL},
	 { (char *)"delete_UnsupportedMessageType", _wrap_delete_UnsupportedMessageType, METH_VARARGS, NULL},
	 { (char *)"UnsupportedMessageType_swigregister", UnsupportedMessageType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnsupportedVersion", _wrap_new_UnsupportedVersion, METH_VARARGS, NULL},
	 { (char *)"delete_UnsupportedVersion", _wrap_delete_UnsupportedVersion, METH_VARARGS, NULL},
	 { (char *)"UnsupportedVersion_swigregister", UnsupportedVersion_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TagOutOfOrder", _wrap_new_TagOutOfOrder, METH_VARARGS, NULL},
	 { (char *)"TagOutOfOrder_field_set", _wrap_TagOutOfOrder_field_set, METH_VARARGS, NULL},
	 { (char *)"TagOutOfOrder_field_get", _wrap_TagOutOfOrder_field_get, METH_VARARGS, NULL},
	 { (char *)"delete_TagOutOfOrder", _wrap_delete_TagOutOfOrder, METH_VARARGS, NULL},
	 { (char *)"TagOutOfOrder_swigregister", TagOutOfOrder_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RepeatedTag", _wrap_new_RepeatedTag, METH_VARARGS, NULL},
	 { (char *)"RepeatedTag_field_set", _wrap_RepeatedTag_field_set, METH_VARARGS, NULL},
	 { (char *)"RepeatedTag_field_get", _wrap_RepeatedTag_field_get, METH_VARARGS, NULL},
	 { (char *)"delete_RepeatedTag", _wrap_delete_RepeatedTag, METH_VARARGS, NULL},
	 { (char *)"RepeatedTag_swigregister", RepeatedTag_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RepeatingGroupCountMismatch", _wrap_new_RepeatingGroupCountMismatch, METH_VARARGS, NULL},
	 { (char *)"RepeatingGroupCountMismatch_field_set", _wrap_RepeatingGroupCountMismatch_field_set, METH_VARARGS, NULL},
	 { (char *)"RepeatingGroupCountMismatch_field_get", _wrap_RepeatingGroupCountMismatch_field_get, METH_VARARGS, NULL},
	 { (char *)"delete_RepeatingGroupCountMismatch", _wrap_delete_RepeatingGroupCountMismatch, METH_VARARGS, NULL},
	 { (char *)"RepeatingGroupCountMismatch_swigregister", RepeatingGroupCountMismatch_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DoNotSend", _wrap_new_DoNotSend, METH_VARARGS, NULL},
	 { (char *)"delete_DoNotSend", _wrap_delete_DoNotSend, METH_VARARGS, NULL},
	 { (char *)"DoNotSend_swigregister", DoNotSend_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RejectLogon", _wrap_new_RejectLogon, METH_VARARGS, NULL},
	 { (char *)"delete_RejectLogon", _wrap_delete_RejectLogon, METH_VARARGS, NULL},
	 { (char *)"RejectLogon_swigregister", RejectLogon_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SessionNotFound", _wrap_new_SessionNotFound, METH_VARARGS, NULL},
	 { (char *)"delete_SessionNotFound", _wrap_delete_SessionNotFound, METH_VARARGS, NULL},
	 { (char *)"SessionNotFound_swigregister", SessionNotFound_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IOException", _wrap_new_IOException, METH_VARARGS, NULL},
	 { (char *)"delete_IOException", _wrap_delete_IOException, METH_VARARGS, NULL},
	 { (char *)"IOException_swigregister", IOException_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SocketException", _wrap_new_SocketException, METH_VARARGS, NULL},
	 { (char *)"SocketException_errorToWhat", _wrap_SocketException_errorToWhat, METH_VARARGS, NULL},
	 { (char *)"SocketException_error_set", _wrap_SocketException_error_set, METH_VARARGS, NULL},
	 { (char *)"SocketException_error_get", _wrap_SocketException_error_get, METH_VARARGS, NULL},
	 { (char *)"delete_SocketException", _wrap_delete_SocketException, METH_VARARGS, NULL},
	 { (char *)"SocketException_swigregister", SocketException_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SocketSendFailed", _wrap_new_SocketSendFailed, METH_VARARGS, NULL},
	 { (char *)"delete_SocketSendFailed", _wrap_delete_SocketSendFailed, METH_VARARGS, NULL},
	 { (char *)"SocketSendFailed_swigregister", SocketSendFailed_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SocketRecvFailed", _wrap_new_SocketRecvFailed, METH_VARARGS, NULL},
	 { (char *)"delete_SocketRecvFailed", _wrap_delete_SocketRecvFailed, METH_VARARGS, NULL},
	 { (char *)"SocketRecvFailed_swigregister", SocketRecvFailed_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SocketCloseFailed", _wrap_new_SocketCloseFailed, METH_VARARGS, NULL},
	 { (char *)"delete_SocketCloseFailed", _wrap_delete_SocketCloseFailed, METH_VARARGS, NULL},
	 { (char *)"SocketCloseFailed_swigregister", SocketCloseFailed_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FieldBase", _wrap_new_FieldBase, METH_VARARGS, NULL},
	 { (char *)"delete_FieldBase", _wrap_delete_FieldBase, METH_VARARGS, NULL},
	 { (char *)"FieldBase_setField", _wrap_FieldBase_setField, METH_VARARGS, NULL},
	 { (char *)"FieldBase_setString", _wrap_FieldBase_setString, METH_VARARGS, NULL},
	 { (char *)"FieldBase_getField", _wrap_FieldBase_getField, METH_VARARGS, NULL},
	 { (char *)"FieldBase_getString", _wrap_FieldBase_getString, METH_VARARGS, NULL},
	 { (char *)"FieldBase_getFixString", _wrap_FieldBase_getFixString, METH_VARARGS, NULL},
	 { (char *)"FieldBase_getLength", _wrap_FieldBase_getLength, METH_VARARGS, NULL},
	 { (char *)"FieldBase_getTotal", _wrap_FieldBase_getTotal, METH_VARARGS, NULL},
	 { (char *)"FieldBase___lt__", _wrap_FieldBase___lt__, METH_VARARGS, NULL},
	 { (char *)"FieldBase___str__", _wrap_FieldBase___str__, METH_VARARGS, NULL},
	 { (char *)"FieldBase_swigregister", FieldBase_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StringField", _wrap_new_StringField, METH_VARARGS, NULL},
	 { (char *)"StringField_setValue", _wrap_StringField_setValue, METH_VARARGS, NULL},
	 { (char *)"StringField_getValue", _wrap_StringField_getValue, METH_VARARGS, NULL},
	 { (char *)"StringField___lt__", _wrap_StringField___lt__, METH_VARARGS, NULL},
	 { (char *)"StringField___gt__", _wrap_StringField___gt__, METH_VARARGS, NULL},
	 { (char *)"StringField___eq__", _wrap_StringField___eq__, METH_VARARGS, NULL},
	 { (char *)"StringField___ne__", _wrap_StringField___ne__, METH_VARARGS, NULL},
	 { (char *)"StringField___le__", _wrap_StringField___le__, METH_VARARGS, NULL},
	 { (char *)"StringField___ge__", _wrap_StringField___ge__, METH_VARARGS, NULL},
	 { (char *)"delete_StringField", _wrap_delete_StringField, METH_VARARGS, NULL},
	 { (char *)"StringField_swigregister", StringField_swigregister, METH_VARARGS, NULL},
	 { (char *)"__gt__", _wrap___gt__, METH_VARARGS, NULL},
	 { (char *)"__le__", _wrap___le__, METH_VARARGS, NULL},
	 { (char *)"__ge__", _wrap___ge__, METH_VARARGS, NULL},
	 { (char *)"new_CharField", _wrap_new_CharField, METH_VARARGS, NULL},
	 { (char *)"CharField_setValue", _wrap_CharField_setValue, METH_VARARGS, NULL},
	 { (char *)"CharField_getValue", _wrap_CharField_getValue, METH_VARARGS, NULL},
	 { (char *)"delete_CharField", _wrap_delete_CharField, METH_VARARGS, NULL},
	 { (char *)"CharField_swigregister", CharField_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DoubleField", _wrap_new_DoubleField, METH_VARARGS, NULL},
	 { (char *)"DoubleField_setValue", _wrap_DoubleField_setValue, METH_VARARGS, NULL},
	 { (char *)"DoubleField_getValue", _wrap_DoubleField_getValue, METH_VARARGS, NULL},
	 { (char *)"delete_DoubleField", _wrap_delete_DoubleField, METH_VARARGS, NULL},
	 { (char *)"DoubleField_swigregister", DoubleField_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IntField", _wrap_new_IntField, METH_VARARGS, NULL},
	 { (char *)"IntField_setValue", _wrap_IntField_setValue, METH_VARARGS, NULL},
	 { (char *)"IntField_getValue", _wrap_IntField_getValue, METH_VARARGS, NULL},
	 { (char *)"delete_IntField", _wrap_delete_IntField, METH_VARARGS, NULL},
	 { (char *)"IntField_swigregister", IntField_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BoolField", _wrap_new_BoolField, METH_VARARGS, NULL},
	 { (char *)"BoolField_setValue", _wrap_BoolField_setValue, METH_VARARGS, NULL},
	 { (char *)"BoolField_getValue", _wrap_BoolField_getValue, METH_VARARGS, NULL},
	 { (char *)"BoolField___nonzero__", _wrap_BoolField___nonzero__, METH_VARARGS, NULL},
	 { (char *)"delete_BoolField", _wrap_delete_BoolField, METH_VARARGS, NULL},
	 { (char *)"BoolField_swigregister", BoolField_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UtcTimeStampField", _wrap_new_UtcTimeStampField, METH_VARARGS, NULL},
	 { (char *)"UtcTimeStampField_setValue", _wrap_UtcTimeStampField_setValue, METH_VARARGS, NULL},
	 { (char *)"UtcTimeStampField_getValue", _wrap_UtcTimeStampField_getValue, METH_VARARGS, NULL},
	 { (char *)"UtcTimeStampField___lt__", _wrap_UtcTimeStampField___lt__, METH_VARARGS, NULL},
	 { (char *)"UtcTimeStampField___eq__", _wrap_UtcTimeStampField___eq__, METH_VARARGS, NULL},
	 { (char *)"UtcTimeStampField___ne__", _wrap_UtcTimeStampField___ne__, METH_VARARGS, NULL},
	 { (char *)"delete_UtcTimeStampField", _wrap_delete_UtcTimeStampField, METH_VARARGS, NULL},
	 { (char *)"UtcTimeStampField_swigregister", UtcTimeStampField_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UtcDateField", _wrap_new_UtcDateField, METH_VARARGS, NULL},
	 { (char *)"UtcDateField_setValue", _wrap_UtcDateField_setValue, METH_VARARGS, NULL},
	 { (char *)"UtcDateField_getValue", _wrap_UtcDateField_getValue, METH_VARARGS, NULL},
	 { (char *)"UtcDateField___lt__", _wrap_UtcDateField___lt__, METH_VARARGS, NULL},
	 { (char *)"UtcDateField___eq__", _wrap_UtcDateField___eq__, METH_VARARGS, NULL},
	 { (char *)"UtcDateField___ne__", _wrap_UtcDateField___ne__, METH_VARARGS, NULL},
	 { (char *)"delete_UtcDateField", _wrap_delete_UtcDateField, METH_VARARGS, NULL},
	 { (char *)"UtcDateField_swigregister", UtcDateField_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UtcTimeOnlyField", _wrap_new_UtcTimeOnlyField, METH_VARARGS, NULL},
	 { (char *)"UtcTimeOnlyField_setValue", _wrap_UtcTimeOnlyField_setValue, METH_VARARGS, NULL},
	 { (char *)"UtcTimeOnlyField_getValue", _wrap_UtcTimeOnlyField_getValue, METH_VARARGS, NULL},
	 { (char *)"UtcTimeOnlyField___lt__", _wrap_UtcTimeOnlyField___lt__, METH_VARARGS, NULL},
	 { (char *)"UtcTimeOnlyField___eq__", _wrap_UtcTimeOnlyField___eq__, METH_VARARGS, NULL},
	 { (char *)"UtcTimeOnlyField___ne__", _wrap_UtcTimeOnlyField___ne__, METH_VARARGS, NULL},
	 { (char *)"delete_UtcTimeOnlyField", _wrap_delete_UtcTimeOnlyField, METH_VARARGS, NULL},
	 { (char *)"UtcTimeOnlyField_swigregister", UtcTimeOnlyField_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CheckSumField", _wrap_new_CheckSumField, METH_VARARGS, NULL},
	 { (char *)"CheckSumField_setValue", _wrap_CheckSumField_setValue, METH_VARARGS, NULL},
	 { (char *)"CheckSumField_getValue", _wrap_CheckSumField_getValue, METH_VARARGS, NULL},
	 { (char *)"delete_CheckSumField", _wrap_delete_CheckSumField, METH_VARARGS, NULL},
	 { (char *)"CheckSumField_swigregister", CheckSumField_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FieldMap", _wrap_new_FieldMap, METH_VARARGS, NULL},
	 { (char *)"delete_FieldMap", _wrap_delete_FieldMap, METH_VARARGS, NULL},
	 { (char *)"FieldMap_setField", _wrap_FieldMap_setField, METH_VARARGS, NULL},
	 { (char *)"FieldMap_getField", _wrap_FieldMap_getField, METH_VARARGS, NULL},
	 { (char *)"FieldMap_getFieldRef", _wrap_FieldMap_getFieldRef, METH_VARARGS, NULL},
	 { (char *)"FieldMap_getFieldPtr", _wrap_FieldMap_getFieldPtr, METH_VARARGS, NULL},
	 { (char *)"FieldMap_isSetField", _wrap_FieldMap_isSetField, METH_VARARGS, NULL},
	 { (char *)"FieldMap_removeField", _wrap_FieldMap_removeField, METH_VARARGS, NULL},
	 { (char *)"FieldMap_addGroup", _wrap_FieldMap_addGroup, METH_VARARGS, NULL},
	 { (char *)"FieldMap_replaceGroup", _wrap_FieldMap_replaceGroup, METH_VARARGS, NULL},
	 { (char *)"FieldMap_getGroup", _wrap_FieldMap_getGroup, METH_VARARGS, NULL},
	 { (char *)"FieldMap_getGroupRef", _wrap_FieldMap_getGroupRef, METH_VARARGS, NULL},
	 { (char *)"FieldMap_getGroupPtr", _wrap_FieldMap_getGroupPtr, METH_VARARGS, NULL},
	 { (char *)"FieldMap_removeGroup", _wrap_FieldMap_removeGroup, METH_VARARGS, NULL},
	 { (char *)"FieldMap_hasGroup", _wrap_FieldMap_hasGroup, METH_VARARGS, NULL},
	 { (char *)"FieldMap_groupCount", _wrap_FieldMap_groupCount, METH_VARARGS, NULL},
	 { (char *)"FieldMap_clear", _wrap_FieldMap_clear, METH_VARARGS, NULL},
	 { (char *)"FieldMap_isEmpty", _wrap_FieldMap_isEmpty, METH_VARARGS, NULL},
	 { (char *)"FieldMap_totalFields", _wrap_FieldMap_totalFields, METH_VARARGS, NULL},
	 { (char *)"FieldMap_calculateString", _wrap_FieldMap_calculateString, METH_VARARGS, NULL},
	 { (char *)"FieldMap_calculateLength", _wrap_FieldMap_calculateLength, METH_VARARGS, NULL},
	 { (char *)"FieldMap_calculateTotal", _wrap_FieldMap_calculateTotal, METH_VARARGS, NULL},
	 { (char *)"FieldMap_begin", _wrap_FieldMap_begin, METH_VARARGS, NULL},
	 { (char *)"FieldMap_end", _wrap_FieldMap_end, METH_VARARGS, NULL},
	 { (char *)"FieldMap_g_begin", _wrap_FieldMap_g_begin, METH_VARARGS, NULL},
	 { (char *)"FieldMap_g_end", _wrap_FieldMap_g_end, METH_VARARGS, NULL},
	 { (char *)"FieldMap_swigregister", FieldMap_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Header", _wrap_new_Header, METH_VARARGS, NULL},
	 { (char *)"delete_Header", _wrap_delete_Header, METH_VARARGS, NULL},
	 { (char *)"Header_swigregister", Header_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Trailer", _wrap_new_Trailer, METH_VARARGS, NULL},
	 { (char *)"delete_Trailer", _wrap_delete_Trailer, METH_VARARGS, NULL},
	 { (char *)"Trailer_swigregister", Trailer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Message", _wrap_new_Message, METH_VARARGS, NULL},
	 { (char *)"Message_InitializeXML", _wrap_Message_InitializeXML, METH_VARARGS, NULL},
	 { (char *)"Message_addGroup", _wrap_Message_addGroup, METH_VARARGS, NULL},
	 { (char *)"Message_replaceGroup", _wrap_Message_replaceGroup, METH_VARARGS, NULL},
	 { (char *)"Message_getGroup", _wrap_Message_getGroup, METH_VARARGS, NULL},
	 { (char *)"Message_removeGroup", _wrap_Message_removeGroup, METH_VARARGS, NULL},
	 { (char *)"Message_hasGroup", _wrap_Message_hasGroup, METH_VARARGS, NULL},
	 { (char *)"Message_toString", _wrap_Message_toString, METH_VARARGS, NULL},
	 { (char *)"Message_toXML", _wrap_Message_toXML, METH_VARARGS, NULL},
	 { (char *)"Message_reverseRoute", _wrap_Message_reverseRoute, METH_VARARGS, NULL},
	 { (char *)"Message_setString", _wrap_Message_setString, METH_VARARGS, NULL},
	 { (char *)"Message_setGroup", _wrap_Message_setGroup, METH_VARARGS, NULL},
	 { (char *)"Message_setStringHeader", _wrap_Message_setStringHeader, METH_VARARGS, NULL},
	 { (char *)"Message_getHeader", _wrap_Message_getHeader, METH_VARARGS, NULL},
	 { (char *)"Message_getTrailer", _wrap_Message_getTrailer, METH_VARARGS, NULL},
	 { (char *)"Message_hasValidStructure", _wrap_Message_hasValidStructure, METH_VARARGS, NULL},
	 { (char *)"Message_bodyLength", _wrap_Message_bodyLength, METH_VARARGS, NULL},
	 { (char *)"Message_checkSum", _wrap_Message_checkSum, METH_VARARGS, NULL},
	 { (char *)"Message_isAdmin", _wrap_Message_isAdmin, METH_VARARGS, NULL},
	 { (char *)"Message_isApp", _wrap_Message_isApp, METH_VARARGS, NULL},
	 { (char *)"Message_isEmpty", _wrap_Message_isEmpty, METH_VARARGS, NULL},
	 { (char *)"Message_clear", _wrap_Message_clear, METH_VARARGS, NULL},
	 { (char *)"Message_isAdminMsgType", _wrap_Message_isAdminMsgType, METH_VARARGS, NULL},
	 { (char *)"Message_toApplVerID", _wrap_Message_toApplVerID, METH_VARARGS, NULL},
	 { (char *)"Message_toBeginString", _wrap_Message_toBeginString, METH_VARARGS, NULL},
	 { (char *)"Message_isHeaderField", _wrap_Message_isHeaderField, METH_VARARGS, NULL},
	 { (char *)"Message_isTrailerField", _wrap_Message_isTrailerField, METH_VARARGS, NULL},
	 { (char *)"Message_getSessionID", _wrap_Message_getSessionID, METH_VARARGS, NULL},
	 { (char *)"Message_setSessionID", _wrap_Message_setSessionID, METH_VARARGS, NULL},
	 { (char *)"Message___str__", _wrap_Message___str__, METH_VARARGS, NULL},
	 { (char *)"delete_Message", _wrap_delete_Message, METH_VARARGS, NULL},
	 { (char *)"Message_swigregister", Message_swigregister, METH_VARARGS, NULL},
	 { (char *)"identifyType", _wrap_identifyType, METH_VARARGS, NULL},
	 { (char *)"new_Group", _wrap_new_Group, METH_VARARGS, NULL},
	 { (char *)"Group_field", _wrap_Group_field, METH_VARARGS, NULL},
	 { (char *)"Group_delim", _wrap_Group_delim, METH_VARARGS, NULL},
	 { (char *)"Group_addGroup", _wrap_Group_addGroup, METH_VARARGS, NULL},
	 { (char *)"Group_replaceGroup", _wrap_Group_replaceGroup, METH_VARARGS, NULL},
	 { (char *)"Group_getGroup", _wrap_Group_getGroup, METH_VARARGS, NULL},
	 { (char *)"Group_removeGroup", _wrap_Group_removeGroup, METH_VARARGS, NULL},
	 { (char *)"Group_hasGroup", _wrap_Group_hasGroup, METH_VARARGS, NULL},
	 { (char *)"delete_Group", _wrap_delete_Group, METH_VARARGS, NULL},
	 { (char *)"Group_swigregister", Group_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaxPriceLevels", _wrap_new_MaxPriceLevels, METH_VARARGS, NULL},
	 { (char *)"delete_MaxPriceLevels", _wrap_delete_MaxPriceLevels, METH_VARARGS, NULL},
	 { (char *)"MaxPriceLevels_swigregister", MaxPriceLevels_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeEncodedIssuer", _wrap_new_DerivativeEncodedIssuer, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeEncodedIssuer", _wrap_delete_DerivativeEncodedIssuer, METH_VARARGS, NULL},
	 { (char *)"DerivativeEncodedIssuer_swigregister", DerivativeEncodedIssuer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoCompIDs", _wrap_new_NoCompIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoCompIDs", _wrap_delete_NoCompIDs, METH_VARARGS, NULL},
	 { (char *)"NoCompIDs_swigregister", NoCompIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlInstRefID", _wrap_new_SettlInstRefID, METH_VARARGS, NULL},
	 { (char *)"delete_SettlInstRefID", _wrap_delete_SettlInstRefID, METH_VARARGS, NULL},
	 { (char *)"SettlInstRefID_swigregister", SettlInstRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NestedPartyID", _wrap_new_NestedPartyID, METH_VARARGS, NULL},
	 { (char *)"delete_NestedPartyID", _wrap_delete_NestedPartyID, METH_VARARGS, NULL},
	 { (char *)"NestedPartyID_swigregister", NestedPartyID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DetachmentPoint", _wrap_new_DetachmentPoint, METH_VARARGS, NULL},
	 { (char *)"delete_DetachmentPoint", _wrap_delete_DetachmentPoint, METH_VARARGS, NULL},
	 { (char *)"DetachmentPoint_swigregister", DetachmentPoint_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LateIndicator", _wrap_new_LateIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_LateIndicator", _wrap_delete_LateIndicator, METH_VARARGS, NULL},
	 { (char *)"LateIndicator_swigregister", LateIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityListID", _wrap_new_SecurityListID, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityListID", _wrap_delete_SecurityListID, METH_VARARGS, NULL},
	 { (char *)"SecurityListID_swigregister", SecurityListID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeFlowScheduleType", _wrap_new_DerivativeFlowScheduleType, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeFlowScheduleType", _wrap_delete_DerivativeFlowScheduleType, METH_VARARGS, NULL},
	 { (char *)"DerivativeFlowScheduleType_swigregister", DerivativeFlowScheduleType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FlexibleIndicator", _wrap_new_FlexibleIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_FlexibleIndicator", _wrap_delete_FlexibleIndicator, METH_VARARGS, NULL},
	 { (char *)"FlexibleIndicator_swigregister", FlexibleIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoExecInstRules", _wrap_new_NoExecInstRules, METH_VARARGS, NULL},
	 { (char *)"delete_NoExecInstRules", _wrap_delete_NoExecInstRules, METH_VARARGS, NULL},
	 { (char *)"NoExecInstRules_swigregister", NoExecInstRules_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideTrdRegTimestamp", _wrap_new_SideTrdRegTimestamp, METH_VARARGS, NULL},
	 { (char *)"delete_SideTrdRegTimestamp", _wrap_delete_SideTrdRegTimestamp, METH_VARARGS, NULL},
	 { (char *)"SideTrdRegTimestamp_swigregister", SideTrdRegTimestamp_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DeliveryForm", _wrap_new_DeliveryForm, METH_VARARGS, NULL},
	 { (char *)"delete_DeliveryForm", _wrap_delete_DeliveryForm, METH_VARARGS, NULL},
	 { (char *)"DeliveryForm_swigregister", DeliveryForm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExecRestatementReason", _wrap_new_ExecRestatementReason, METH_VARARGS, NULL},
	 { (char *)"delete_ExecRestatementReason", _wrap_delete_ExecRestatementReason, METH_VARARGS, NULL},
	 { (char *)"ExecRestatementReason_swigregister", ExecRestatementReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MidYield", _wrap_new_MidYield, METH_VARARGS, NULL},
	 { (char *)"delete_MidYield", _wrap_delete_MidYield, METH_VARARGS, NULL},
	 { (char *)"MidYield_swigregister", MidYield_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ContractMultiplier", _wrap_new_ContractMultiplier, METH_VARARGS, NULL},
	 { (char *)"delete_ContractMultiplier", _wrap_delete_ContractMultiplier, METH_VARARGS, NULL},
	 { (char *)"ContractMultiplier_swigregister", ContractMultiplier_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CcyAmt", _wrap_new_CcyAmt, METH_VARARGS, NULL},
	 { (char *)"delete_CcyAmt", _wrap_delete_CcyAmt, METH_VARARGS, NULL},
	 { (char *)"CcyAmt_swigregister", CcyAmt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegOrderQty", _wrap_new_LegOrderQty, METH_VARARGS, NULL},
	 { (char *)"delete_LegOrderQty", _wrap_delete_LegOrderQty, METH_VARARGS, NULL},
	 { (char *)"LegOrderQty_swigregister", LegOrderQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocIntermedReqType", _wrap_new_AllocIntermedReqType, METH_VARARGS, NULL},
	 { (char *)"delete_AllocIntermedReqType", _wrap_delete_AllocIntermedReqType, METH_VARARGS, NULL},
	 { (char *)"AllocIntermedReqType_swigregister", AllocIntermedReqType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingIssuer", _wrap_new_UnderlyingIssuer, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingIssuer", _wrap_delete_UnderlyingIssuer, METH_VARARGS, NULL},
	 { (char *)"UnderlyingIssuer_swigregister", UnderlyingIssuer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoNested2PartyIDs", _wrap_new_NoNested2PartyIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoNested2PartyIDs", _wrap_delete_NoNested2PartyIDs, METH_VARARGS, NULL},
	 { (char *)"NoNested2PartyIDs_swigregister", NoNested2PartyIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MinTradeVol", _wrap_new_MinTradeVol, METH_VARARGS, NULL},
	 { (char *)"delete_MinTradeVol", _wrap_delete_MinTradeVol, METH_VARARGS, NULL},
	 { (char *)"MinTradeVol_swigregister", MinTradeVol_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlCurrAmt", _wrap_new_SettlCurrAmt, METH_VARARGS, NULL},
	 { (char *)"delete_SettlCurrAmt", _wrap_delete_SettlCurrAmt, METH_VARARGS, NULL},
	 { (char *)"SettlCurrAmt_swigregister", SettlCurrAmt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeInstrumentPartyRole", _wrap_new_DerivativeInstrumentPartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeInstrumentPartyRole", _wrap_delete_DerivativeInstrumentPartyRole, METH_VARARGS, NULL},
	 { (char *)"DerivativeInstrumentPartyRole_swigregister", DerivativeInstrumentPartyRole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_YieldRedemptionPriceType", _wrap_new_YieldRedemptionPriceType, METH_VARARGS, NULL},
	 { (char *)"delete_YieldRedemptionPriceType", _wrap_delete_YieldRedemptionPriceType, METH_VARARGS, NULL},
	 { (char *)"YieldRedemptionPriceType_swigregister", YieldRedemptionPriceType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NewsRefID", _wrap_new_NewsRefID, METH_VARARGS, NULL},
	 { (char *)"delete_NewsRefID", _wrap_delete_NewsRefID, METH_VARARGS, NULL},
	 { (char *)"NewsRefID_swigregister", NewsRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityListTypeSource", _wrap_new_SecurityListTypeSource, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityListTypeSource", _wrap_delete_SecurityListTypeSource, METH_VARARGS, NULL},
	 { (char *)"SecurityListTypeSource_swigregister", SecurityListTypeSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplReqID", _wrap_new_ApplReqID, METH_VARARGS, NULL},
	 { (char *)"delete_ApplReqID", _wrap_delete_ApplReqID, METH_VARARGS, NULL},
	 { (char *)"ApplReqID_swigregister", ApplReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeFuturesValuationMethod", _wrap_new_DerivativeFuturesValuationMethod, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeFuturesValuationMethod", _wrap_delete_DerivativeFuturesValuationMethod, METH_VARARGS, NULL},
	 { (char *)"DerivativeFuturesValuationMethod_swigregister", DerivativeFuturesValuationMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoLegSecurityAltID", _wrap_new_NoLegSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"delete_NoLegSecurityAltID", _wrap_delete_NoLegSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"NoLegSecurityAltID_swigregister", NoLegSecurityAltID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSecurityType", _wrap_new_DerivativeSecurityType, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSecurityType", _wrap_delete_DerivativeSecurityType, METH_VARARGS, NULL},
	 { (char *)"DerivativeSecurityType_swigregister", DerivativeSecurityType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollInquiryQualifier", _wrap_new_CollInquiryQualifier, METH_VARARGS, NULL},
	 { (char *)"delete_CollInquiryQualifier", _wrap_delete_CollInquiryQualifier, METH_VARARGS, NULL},
	 { (char *)"CollInquiryQualifier_swigregister", CollInquiryQualifier_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RawData", _wrap_new_RawData, METH_VARARGS, NULL},
	 { (char *)"delete_RawData", _wrap_delete_RawData, METH_VARARGS, NULL},
	 { (char *)"RawData_swigregister", RawData_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashSettlAgentContactPhone", _wrap_new_CashSettlAgentContactPhone, METH_VARARGS, NULL},
	 { (char *)"delete_CashSettlAgentContactPhone", _wrap_delete_CashSettlAgentContactPhone, METH_VARARGS, NULL},
	 { (char *)"CashSettlAgentContactPhone_swigregister", CashSettlAgentContactPhone_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CreditRating", _wrap_new_CreditRating, METH_VARARGS, NULL},
	 { (char *)"delete_CreditRating", _wrap_delete_CreditRating, METH_VARARGS, NULL},
	 { (char *)"CreditRating_swigregister", CreditRating_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ContingencyType", _wrap_new_ContingencyType, METH_VARARGS, NULL},
	 { (char *)"delete_ContingencyType", _wrap_delete_ContingencyType, METH_VARARGS, NULL},
	 { (char *)"ContingencyType_swigregister", ContingencyType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StrikeCurrency", _wrap_new_StrikeCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_StrikeCurrency", _wrap_delete_StrikeCurrency, METH_VARARGS, NULL},
	 { (char *)"StrikeCurrency_swigregister", StrikeCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeVolume", _wrap_new_TradeVolume, METH_VARARGS, NULL},
	 { (char *)"delete_TradeVolume", _wrap_delete_TradeVolume, METH_VARARGS, NULL},
	 { (char *)"TradeVolume_swigregister", TradeVolume_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideTrdRegTimestampSrc", _wrap_new_SideTrdRegTimestampSrc, METH_VARARGS, NULL},
	 { (char *)"delete_SideTrdRegTimestampSrc", _wrap_delete_SideTrdRegTimestampSrc, METH_VARARGS, NULL},
	 { (char *)"SideTrdRegTimestampSrc_swigregister", SideTrdRegTimestampSrc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DeliveryDate", _wrap_new_DeliveryDate, METH_VARARGS, NULL},
	 { (char *)"delete_DeliveryDate", _wrap_delete_DeliveryDate, METH_VARARGS, NULL},
	 { (char *)"DeliveryDate_swigregister", DeliveryDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EmailType", _wrap_new_EmailType, METH_VARARGS, NULL},
	 { (char *)"delete_EmailType", _wrap_delete_EmailType, METH_VARARGS, NULL},
	 { (char *)"EmailType_swigregister", EmailType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedListExecInst", _wrap_new_EncodedListExecInst, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedListExecInst", _wrap_delete_EncodedListExecInst, METH_VARARGS, NULL},
	 { (char *)"EncodedListExecInst_swigregister", EncodedListExecInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ContraTradeTime", _wrap_new_ContraTradeTime, METH_VARARGS, NULL},
	 { (char *)"delete_ContraTradeTime", _wrap_delete_ContraTradeTime, METH_VARARGS, NULL},
	 { (char *)"ContraTradeTime_swigregister", ContraTradeTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaturityMonthYearIncrement", _wrap_new_MaturityMonthYearIncrement, METH_VARARGS, NULL},
	 { (char *)"delete_MaturityMonthYearIncrement", _wrap_delete_MaturityMonthYearIncrement, METH_VARARGS, NULL},
	 { (char *)"MaturityMonthYearIncrement_swigregister", MaturityMonthYearIncrement_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RootPartyIDSource", _wrap_new_RootPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_RootPartyIDSource", _wrap_delete_RootPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"RootPartyIDSource_swigregister", RootPartyIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingCouponPaymentDate", _wrap_new_UnderlyingCouponPaymentDate, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingCouponPaymentDate", _wrap_delete_UnderlyingCouponPaymentDate, METH_VARARGS, NULL},
	 { (char *)"UnderlyingCouponPaymentDate_swigregister", UnderlyingCouponPaymentDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BidYield", _wrap_new_BidYield, METH_VARARGS, NULL},
	 { (char *)"delete_BidYield", _wrap_delete_BidYield, METH_VARARGS, NULL},
	 { (char *)"BidYield_swigregister", BidYield_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IOIQltyInd", _wrap_new_IOIQltyInd, METH_VARARGS, NULL},
	 { (char *)"delete_IOIQltyInd", _wrap_delete_IOIQltyInd, METH_VARARGS, NULL},
	 { (char *)"IOIQltyInd_swigregister", IOIQltyInd_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Issuer", _wrap_new_Issuer, METH_VARARGS, NULL},
	 { (char *)"delete_Issuer", _wrap_delete_Issuer, METH_VARARGS, NULL},
	 { (char *)"Issuer_swigregister", Issuer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CardNumber", _wrap_new_CardNumber, METH_VARARGS, NULL},
	 { (char *)"delete_CardNumber", _wrap_delete_CardNumber, METH_VARARGS, NULL},
	 { (char *)"CardNumber_swigregister", CardNumber_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoLegStipulations", _wrap_new_NoLegStipulations, METH_VARARGS, NULL},
	 { (char *)"delete_NoLegStipulations", _wrap_delete_NoLegStipulations, METH_VARARGS, NULL},
	 { (char *)"NoLegStipulations_swigregister", NoLegStipulations_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSecurityExchange", _wrap_new_LegSecurityExchange, METH_VARARGS, NULL},
	 { (char *)"delete_LegSecurityExchange", _wrap_delete_LegSecurityExchange, METH_VARARGS, NULL},
	 { (char *)"LegSecurityExchange_swigregister", LegSecurityExchange_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashOrderQty", _wrap_new_CashOrderQty, METH_VARARGS, NULL},
	 { (char *)"delete_CashOrderQty", _wrap_delete_CashOrderQty, METH_VARARGS, NULL},
	 { (char *)"CashOrderQty_swigregister", CashOrderQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AccruedInterestAmt", _wrap_new_AccruedInterestAmt, METH_VARARGS, NULL},
	 { (char *)"delete_AccruedInterestAmt", _wrap_delete_AccruedInterestAmt, METH_VARARGS, NULL},
	 { (char *)"AccruedInterestAmt_swigregister", AccruedInterestAmt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDEntrySeller", _wrap_new_MDEntrySeller, METH_VARARGS, NULL},
	 { (char *)"delete_MDEntrySeller", _wrap_delete_MDEntrySeller, METH_VARARGS, NULL},
	 { (char *)"MDEntrySeller_swigregister", MDEntrySeller_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegPrice", _wrap_new_LegPrice, METH_VARARGS, NULL},
	 { (char *)"delete_LegPrice", _wrap_delete_LegPrice, METH_VARARGS, NULL},
	 { (char *)"LegPrice_swigregister", LegPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DeliverToCompID", _wrap_new_DeliverToCompID, METH_VARARGS, NULL},
	 { (char *)"delete_DeliverToCompID", _wrap_delete_DeliverToCompID, METH_VARARGS, NULL},
	 { (char *)"DeliverToCompID_swigregister", DeliverToCompID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TargetLocationID", _wrap_new_TargetLocationID, METH_VARARGS, NULL},
	 { (char *)"delete_TargetLocationID", _wrap_delete_TargetLocationID, METH_VARARGS, NULL},
	 { (char *)"TargetLocationID_swigregister", TargetLocationID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OfferForwardPoints2", _wrap_new_OfferForwardPoints2, METH_VARARGS, NULL},
	 { (char *)"delete_OfferForwardPoints2", _wrap_delete_OfferForwardPoints2, METH_VARARGS, NULL},
	 { (char *)"OfferForwardPoints2_swigregister", OfferForwardPoints2_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RatioQty", _wrap_new_RatioQty, METH_VARARGS, NULL},
	 { (char *)"delete_RatioQty", _wrap_delete_RatioQty, METH_VARARGS, NULL},
	 { (char *)"RatioQty_swigregister", RatioQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MultiLegRptTypeReq", _wrap_new_MultiLegRptTypeReq, METH_VARARGS, NULL},
	 { (char *)"delete_MultiLegRptTypeReq", _wrap_delete_MultiLegRptTypeReq, METH_VARARGS, NULL},
	 { (char *)"MultiLegRptTypeReq_swigregister", MultiLegRptTypeReq_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocAccount", _wrap_new_AllocAccount, METH_VARARGS, NULL},
	 { (char *)"delete_AllocAccount", _wrap_delete_AllocAccount, METH_VARARGS, NULL},
	 { (char *)"AllocAccount_swigregister", AllocAccount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotalVolumeTraded", _wrap_new_TotalVolumeTraded, METH_VARARGS, NULL},
	 { (char *)"delete_TotalVolumeTraded", _wrap_delete_TotalVolumeTraded, METH_VARARGS, NULL},
	 { (char *)"TotalVolumeTraded_swigregister", TotalVolumeTraded_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LinesOfText", _wrap_new_LinesOfText, METH_VARARGS, NULL},
	 { (char *)"delete_LinesOfText", _wrap_delete_LinesOfText, METH_VARARGS, NULL},
	 { (char *)"LinesOfText_swigregister", LinesOfText_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AccountType", _wrap_new_AccountType, METH_VARARGS, NULL},
	 { (char *)"delete_AccountType", _wrap_delete_AccountType, METH_VARARGS, NULL},
	 { (char *)"AccountType_swigregister", AccountType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDEntryPositionNo", _wrap_new_MDEntryPositionNo, METH_VARARGS, NULL},
	 { (char *)"delete_MDEntryPositionNo", _wrap_delete_MDEntryPositionNo, METH_VARARGS, NULL},
	 { (char *)"MDEntryPositionNo_swigregister", MDEntryPositionNo_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HaltReasonInt", _wrap_new_HaltReasonInt, METH_VARARGS, NULL},
	 { (char *)"delete_HaltReasonInt", _wrap_delete_HaltReasonInt, METH_VARARGS, NULL},
	 { (char *)"HaltReasonInt_swigregister", HaltReasonInt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FutSettDate", _wrap_new_FutSettDate, METH_VARARGS, NULL},
	 { (char *)"delete_FutSettDate", _wrap_delete_FutSettDate, METH_VARARGS, NULL},
	 { (char *)"FutSettDate_swigregister", FutSettDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityDesc", _wrap_new_SecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityDesc", _wrap_delete_SecurityDesc, METH_VARARGS, NULL},
	 { (char *)"SecurityDesc_swigregister", SecurityDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MinQty", _wrap_new_MinQty, METH_VARARGS, NULL},
	 { (char *)"delete_MinQty", _wrap_delete_MinQty, METH_VARARGS, NULL},
	 { (char *)"MinQty_swigregister", MinQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlCurrency", _wrap_new_SettlCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_SettlCurrency", _wrap_delete_SettlCurrency, METH_VARARGS, NULL},
	 { (char *)"SettlCurrency_swigregister", SettlCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PegOffsetValue", _wrap_new_PegOffsetValue, METH_VARARGS, NULL},
	 { (char *)"delete_PegOffsetValue", _wrap_delete_PegOffsetValue, METH_VARARGS, NULL},
	 { (char *)"PegOffsetValue_swigregister", PegOffsetValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSecurityAltIDSource", _wrap_new_DerivativeSecurityAltIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSecurityAltIDSource", _wrap_delete_DerivativeSecurityAltIDSource, METH_VARARGS, NULL},
	 { (char *)"DerivativeSecurityAltIDSource_swigregister", DerivativeSecurityAltIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoSettlPartySubIDs", _wrap_new_NoSettlPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoSettlPartySubIDs", _wrap_delete_NoSettlPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"NoSettlPartySubIDs_swigregister", NoSettlPartySubIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocReportID", _wrap_new_AllocReportID, METH_VARARGS, NULL},
	 { (char *)"delete_AllocReportID", _wrap_delete_AllocReportID, METH_VARARGS, NULL},
	 { (char *)"AllocReportID_swigregister", AllocReportID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegCFICode", _wrap_new_LegCFICode, METH_VARARGS, NULL},
	 { (char *)"delete_LegCFICode", _wrap_delete_LegCFICode, METH_VARARGS, NULL},
	 { (char *)"LegCFICode_swigregister", LegCFICode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegFutSettDate", _wrap_new_LegFutSettDate, METH_VARARGS, NULL},
	 { (char *)"delete_LegFutSettDate", _wrap_delete_LegFutSettDate, METH_VARARGS, NULL},
	 { (char *)"LegFutSettDate_swigregister", LegFutSettDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegBenchmarkCurveName", _wrap_new_LegBenchmarkCurveName, METH_VARARGS, NULL},
	 { (char *)"delete_LegBenchmarkCurveName", _wrap_delete_LegBenchmarkCurveName, METH_VARARGS, NULL},
	 { (char *)"LegBenchmarkCurveName_swigregister", LegBenchmarkCurveName_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ClearingFeeIndicator", _wrap_new_ClearingFeeIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_ClearingFeeIndicator", _wrap_delete_ClearingFeeIndicator, METH_VARARGS, NULL},
	 { (char *)"ClearingFeeIndicator_swigregister", ClearingFeeIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BrokerOfCredit", _wrap_new_BrokerOfCredit, METH_VARARGS, NULL},
	 { (char *)"delete_BrokerOfCredit", _wrap_delete_BrokerOfCredit, METH_VARARGS, NULL},
	 { (char *)"BrokerOfCredit_swigregister", BrokerOfCredit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityListRefID", _wrap_new_SecurityListRefID, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityListRefID", _wrap_delete_SecurityListRefID, METH_VARARGS, NULL},
	 { (char *)"SecurityListRefID_swigregister", SecurityListRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegMaturityTime", _wrap_new_UnderlyingLegMaturityTime, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegMaturityTime", _wrap_delete_UnderlyingLegMaturityTime, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegMaturityTime_swigregister", UnderlyingLegMaturityTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NestedPartySubIDType", _wrap_new_NestedPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_NestedPartySubIDType", _wrap_delete_NestedPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"NestedPartySubIDType_swigregister", NestedPartySubIDType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BidType", _wrap_new_BidType, METH_VARARGS, NULL},
	 { (char *)"delete_BidType", _wrap_delete_BidType, METH_VARARGS, NULL},
	 { (char *)"BidType_swigregister", BidType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDEntryRefID", _wrap_new_MDEntryRefID, METH_VARARGS, NULL},
	 { (char *)"delete_MDEntryRefID", _wrap_delete_MDEntryRefID, METH_VARARGS, NULL},
	 { (char *)"MDEntryRefID_swigregister", MDEntryRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingUnitOfMeasureQty", _wrap_new_UnderlyingUnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingUnitOfMeasureQty", _wrap_delete_UnderlyingUnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"UnderlyingUnitOfMeasureQty_swigregister", UnderlyingUnitOfMeasureQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegMaturityDate", _wrap_new_UnderlyingLegMaturityDate, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegMaturityDate", _wrap_delete_UnderlyingLegMaturityDate, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegMaturityDate_swigregister", UnderlyingLegMaturityDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StartTickPriceRange", _wrap_new_StartTickPriceRange, METH_VARARGS, NULL},
	 { (char *)"delete_StartTickPriceRange", _wrap_delete_StartTickPriceRange, METH_VARARGS, NULL},
	 { (char *)"StartTickPriceRange_swigregister", StartTickPriceRange_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegContractSettlMonth", _wrap_new_LegContractSettlMonth, METH_VARARGS, NULL},
	 { (char *)"delete_LegContractSettlMonth", _wrap_delete_LegContractSettlMonth, METH_VARARGS, NULL},
	 { (char *)"LegContractSettlMonth_swigregister", LegContractSettlMonth_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSecurityDesc", _wrap_new_UnderlyingSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSecurityDesc", _wrap_delete_UnderlyingSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSecurityDesc_swigregister", UnderlyingSecurityDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashDistribPayRef", _wrap_new_CashDistribPayRef, METH_VARARGS, NULL},
	 { (char *)"delete_CashDistribPayRef", _wrap_delete_CashDistribPayRef, METH_VARARGS, NULL},
	 { (char *)"CashDistribPayRef_swigregister", CashDistribPayRef_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuotePriceType", _wrap_new_QuotePriceType, METH_VARARGS, NULL},
	 { (char *)"delete_QuotePriceType", _wrap_delete_QuotePriceType, METH_VARARGS, NULL},
	 { (char *)"QuotePriceType_swigregister", QuotePriceType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedAllocText", _wrap_new_EncodedAllocText, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedAllocText", _wrap_delete_EncodedAllocText, METH_VARARGS, NULL},
	 { (char *)"EncodedAllocText_swigregister", EncodedAllocText_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingMaturityMonthYear", _wrap_new_UnderlyingMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingMaturityMonthYear", _wrap_delete_UnderlyingMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"UnderlyingMaturityMonthYear_swigregister", UnderlyingMaturityMonthYear_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingOriginalNotionalPercentageOutstanding", _wrap_new_UnderlyingOriginalNotionalPercentageOutstanding, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingOriginalNotionalPercentageOutstanding", _wrap_delete_UnderlyingOriginalNotionalPercentageOutstanding, METH_VARARGS, NULL},
	 { (char *)"UnderlyingOriginalNotionalPercentageOutstanding_swigregister", UnderlyingOriginalNotionalPercentageOutstanding_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MultilegPriceMethod", _wrap_new_MultilegPriceMethod, METH_VARARGS, NULL},
	 { (char *)"delete_MultilegPriceMethod", _wrap_delete_MultilegPriceMethod, METH_VARARGS, NULL},
	 { (char *)"MultilegPriceMethod_swigregister", MultilegPriceMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotNoFills", _wrap_new_TotNoFills, METH_VARARGS, NULL},
	 { (char *)"delete_TotNoFills", _wrap_delete_TotNoFills, METH_VARARGS, NULL},
	 { (char *)"TotNoFills_swigregister", TotNoFills_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSettleOnOpenFlag", _wrap_new_DerivativeSettleOnOpenFlag, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSettleOnOpenFlag", _wrap_delete_DerivativeSettleOnOpenFlag, METH_VARARGS, NULL},
	 { (char *)"DerivativeSettleOnOpenFlag_swigregister", DerivativeSettleOnOpenFlag_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingRepurchaseTerm", _wrap_new_UnderlyingRepurchaseTerm, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingRepurchaseTerm", _wrap_delete_UnderlyingRepurchaseTerm, METH_VARARGS, NULL},
	 { (char *)"UnderlyingRepurchaseTerm_swigregister", UnderlyingRepurchaseTerm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeCountryOfIssue", _wrap_new_DerivativeCountryOfIssue, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeCountryOfIssue", _wrap_delete_DerivativeCountryOfIssue, METH_VARARGS, NULL},
	 { (char *)"DerivativeCountryOfIssue_swigregister", DerivativeCountryOfIssue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ListMethod", _wrap_new_ListMethod, METH_VARARGS, NULL},
	 { (char *)"delete_ListMethod", _wrap_delete_ListMethod, METH_VARARGS, NULL},
	 { (char *)"ListMethod_swigregister", ListMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingCPProgram", _wrap_new_UnderlyingCPProgram, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingCPProgram", _wrap_delete_UnderlyingCPProgram, METH_VARARGS, NULL},
	 { (char *)"UnderlyingCPProgram_swigregister", UnderlyingCPProgram_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PriceDelta", _wrap_new_PriceDelta, METH_VARARGS, NULL},
	 { (char *)"delete_PriceDelta", _wrap_delete_PriceDelta, METH_VARARGS, NULL},
	 { (char *)"PriceDelta_swigregister", PriceDelta_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefSeqNum", _wrap_new_RefSeqNum, METH_VARARGS, NULL},
	 { (char *)"delete_RefSeqNum", _wrap_delete_RefSeqNum, METH_VARARGS, NULL},
	 { (char *)"RefSeqNum_swigregister", RefSeqNum_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AutoAcceptIndicator", _wrap_new_AutoAcceptIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_AutoAcceptIndicator", _wrap_delete_AutoAcceptIndicator, METH_VARARGS, NULL},
	 { (char *)"AutoAcceptIndicator_swigregister", AutoAcceptIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDImplicitDelete", _wrap_new_MDImplicitDelete, METH_VARARGS, NULL},
	 { (char *)"delete_MDImplicitDelete", _wrap_delete_MDImplicitDelete, METH_VARARGS, NULL},
	 { (char *)"MDImplicitDelete_swigregister", MDImplicitDelete_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoStipulations", _wrap_new_NoStipulations, METH_VARARGS, NULL},
	 { (char *)"delete_NoStipulations", _wrap_delete_NoStipulations, METH_VARARGS, NULL},
	 { (char *)"NoStipulations_swigregister", NoStipulations_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ClearingBusinessDate", _wrap_new_ClearingBusinessDate, METH_VARARGS, NULL},
	 { (char *)"delete_ClearingBusinessDate", _wrap_delete_ClearingBusinessDate, METH_VARARGS, NULL},
	 { (char *)"ClearingBusinessDate_swigregister", ClearingBusinessDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LocationID", _wrap_new_LocationID, METH_VARARGS, NULL},
	 { (char *)"delete_LocationID", _wrap_delete_LocationID, METH_VARARGS, NULL},
	 { (char *)"LocationID_swigregister", LocationID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Currency", _wrap_new_Currency, METH_VARARGS, NULL},
	 { (char *)"delete_Currency", _wrap_delete_Currency, METH_VARARGS, NULL},
	 { (char *)"Currency_swigregister", Currency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RoutingType", _wrap_new_RoutingType, METH_VARARGS, NULL},
	 { (char *)"delete_RoutingType", _wrap_delete_RoutingType, METH_VARARGS, NULL},
	 { (char *)"RoutingType_swigregister", RoutingType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingStrikePrice", _wrap_new_UnderlyingStrikePrice, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingStrikePrice", _wrap_delete_UnderlyingStrikePrice, METH_VARARGS, NULL},
	 { (char *)"UnderlyingStrikePrice_swigregister", UnderlyingStrikePrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BidTradeType", _wrap_new_BidTradeType, METH_VARARGS, NULL},
	 { (char *)"delete_BidTradeType", _wrap_delete_BidTradeType, METH_VARARGS, NULL},
	 { (char *)"BidTradeType_swigregister", BidTradeType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingAttachmentPoint", _wrap_new_UnderlyingAttachmentPoint, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingAttachmentPoint", _wrap_delete_UnderlyingAttachmentPoint, METH_VARARGS, NULL},
	 { (char *)"UnderlyingAttachmentPoint_swigregister", UnderlyingAttachmentPoint_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotNoRejQuotes", _wrap_new_TotNoRejQuotes, METH_VARARGS, NULL},
	 { (char *)"delete_TotNoRejQuotes", _wrap_delete_TotNoRejQuotes, METH_VARARGS, NULL},
	 { (char *)"TotNoRejQuotes_swigregister", TotNoRejQuotes_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrdStatusReqID", _wrap_new_OrdStatusReqID, METH_VARARGS, NULL},
	 { (char *)"delete_OrdStatusReqID", _wrap_delete_OrdStatusReqID, METH_VARARGS, NULL},
	 { (char *)"OrdStatusReqID_swigregister", OrdStatusReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SenderCompID", _wrap_new_SenderCompID, METH_VARARGS, NULL},
	 { (char *)"delete_SenderCompID", _wrap_delete_SenderCompID, METH_VARARGS, NULL},
	 { (char *)"SenderCompID_swigregister", SenderCompID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrdRejReason", _wrap_new_OrdRejReason, METH_VARARGS, NULL},
	 { (char *)"delete_OrdRejReason", _wrap_delete_OrdRejReason, METH_VARARGS, NULL},
	 { (char *)"OrdRejReason_swigregister", OrdRejReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaturityMonthYearIncrementUnits", _wrap_new_MaturityMonthYearIncrementUnits, METH_VARARGS, NULL},
	 { (char *)"delete_MaturityMonthYearIncrementUnits", _wrap_delete_MaturityMonthYearIncrementUnits, METH_VARARGS, NULL},
	 { (char *)"MaturityMonthYearIncrementUnits_swigregister", MaturityMonthYearIncrementUnits_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DisplayWhen", _wrap_new_DisplayWhen, METH_VARARGS, NULL},
	 { (char *)"delete_DisplayWhen", _wrap_delete_DisplayWhen, METH_VARARGS, NULL},
	 { (char *)"DisplayWhen_swigregister", DisplayWhen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplQueueAction", _wrap_new_ApplQueueAction, METH_VARARGS, NULL},
	 { (char *)"delete_ApplQueueAction", _wrap_delete_ApplQueueAction, METH_VARARGS, NULL},
	 { (char *)"ApplQueueAction_swigregister", ApplQueueAction_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RegistTransType", _wrap_new_RegistTransType, METH_VARARGS, NULL},
	 { (char *)"delete_RegistTransType", _wrap_delete_RegistTransType, METH_VARARGS, NULL},
	 { (char *)"RegistTransType_swigregister", RegistTransType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PaymentRemitterID", _wrap_new_PaymentRemitterID, METH_VARARGS, NULL},
	 { (char *)"delete_PaymentRemitterID", _wrap_delete_PaymentRemitterID, METH_VARARGS, NULL},
	 { (char *)"PaymentRemitterID_swigregister", PaymentRemitterID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PriceType", _wrap_new_PriceType, METH_VARARGS, NULL},
	 { (char *)"delete_PriceType", _wrap_delete_PriceType, METH_VARARGS, NULL},
	 { (char *)"PriceType_swigregister", PriceType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MarketReqID", _wrap_new_MarketReqID, METH_VARARGS, NULL},
	 { (char *)"delete_MarketReqID", _wrap_delete_MarketReqID, METH_VARARGS, NULL},
	 { (char *)"MarketReqID_swigregister", MarketReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoNestedInstrAttrib", _wrap_new_NoNestedInstrAttrib, METH_VARARGS, NULL},
	 { (char *)"delete_NoNestedInstrAttrib", _wrap_delete_NoNestedInstrAttrib, METH_VARARGS, NULL},
	 { (char *)"NoNestedInstrAttrib_swigregister", NoNestedInstrAttrib_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecuritySubType", _wrap_new_SecuritySubType, METH_VARARGS, NULL},
	 { (char *)"delete_SecuritySubType", _wrap_delete_SecuritySubType, METH_VARARGS, NULL},
	 { (char *)"SecuritySubType_swigregister", SecuritySubType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ClOrdID", _wrap_new_ClOrdID, METH_VARARGS, NULL},
	 { (char *)"delete_ClOrdID", _wrap_delete_ClOrdID, METH_VARARGS, NULL},
	 { (char *)"ClOrdID_swigregister", ClOrdID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaturityDay", _wrap_new_MaturityDay, METH_VARARGS, NULL},
	 { (char *)"delete_MaturityDay", _wrap_delete_MaturityDay, METH_VARARGS, NULL},
	 { (char *)"MaturityDay_swigregister", MaturityDay_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSeniority", _wrap_new_UnderlyingSeniority, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSeniority", _wrap_delete_UnderlyingSeniority, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSeniority_swigregister", UnderlyingSeniority_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MarketSegmentDesc", _wrap_new_MarketSegmentDesc, METH_VARARGS, NULL},
	 { (char *)"delete_MarketSegmentDesc", _wrap_delete_MarketSegmentDesc, METH_VARARGS, NULL},
	 { (char *)"MarketSegmentDesc_swigregister", MarketSegmentDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoMarketSegments", _wrap_new_NoMarketSegments, METH_VARARGS, NULL},
	 { (char *)"delete_NoMarketSegments", _wrap_delete_NoMarketSegments, METH_VARARGS, NULL},
	 { (char *)"NoMarketSegments_swigregister", NoMarketSegments_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlObligMode", _wrap_new_SettlObligMode, METH_VARARGS, NULL},
	 { (char *)"delete_SettlObligMode", _wrap_delete_SettlObligMode, METH_VARARGS, NULL},
	 { (char *)"SettlObligMode_swigregister", SettlObligMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityUpdateAction", _wrap_new_SecurityUpdateAction, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityUpdateAction", _wrap_delete_SecurityUpdateAction, METH_VARARGS, NULL},
	 { (char *)"SecurityUpdateAction_swigregister", SecurityUpdateAction_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NetworkRequestType", _wrap_new_NetworkRequestType, METH_VARARGS, NULL},
	 { (char *)"delete_NetworkRequestType", _wrap_delete_NetworkRequestType, METH_VARARGS, NULL},
	 { (char *)"NetworkRequestType_swigregister", NetworkRequestType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LiquidityPctLow", _wrap_new_LiquidityPctLow, METH_VARARGS, NULL},
	 { (char *)"delete_LiquidityPctLow", _wrap_delete_LiquidityPctLow, METH_VARARGS, NULL},
	 { (char *)"LiquidityPctLow_swigregister", LiquidityPctLow_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PartyRole", _wrap_new_PartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_PartyRole", _wrap_delete_PartyRole, METH_VARARGS, NULL},
	 { (char *)"PartyRole_swigregister", PartyRole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegRatioQty", _wrap_new_LegRatioQty, METH_VARARGS, NULL},
	 { (char *)"delete_LegRatioQty", _wrap_delete_LegRatioQty, METH_VARARGS, NULL},
	 { (char *)"LegRatioQty_swigregister", LegRatioQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlCurrFxRate", _wrap_new_SettlCurrFxRate, METH_VARARGS, NULL},
	 { (char *)"delete_SettlCurrFxRate", _wrap_delete_SettlCurrFxRate, METH_VARARGS, NULL},
	 { (char *)"SettlCurrFxRate_swigregister", SettlCurrFxRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegContractMultiplierUnit", _wrap_new_LegContractMultiplierUnit, METH_VARARGS, NULL},
	 { (char *)"delete_LegContractMultiplierUnit", _wrap_delete_LegContractMultiplierUnit, METH_VARARGS, NULL},
	 { (char *)"LegContractMultiplierUnit_swigregister", LegContractMultiplierUnit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecureData", _wrap_new_SecureData, METH_VARARGS, NULL},
	 { (char *)"delete_SecureData", _wrap_delete_SecureData, METH_VARARGS, NULL},
	 { (char *)"SecureData_swigregister", SecureData_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SenderLocationID", _wrap_new_SenderLocationID, METH_VARARGS, NULL},
	 { (char *)"delete_SenderLocationID", _wrap_delete_SenderLocationID, METH_VARARGS, NULL},
	 { (char *)"SenderLocationID_swigregister", SenderLocationID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FirstPx", _wrap_new_FirstPx, METH_VARARGS, NULL},
	 { (char *)"delete_FirstPx", _wrap_delete_FirstPx, METH_VARARGS, NULL},
	 { (char *)"FirstPx_swigregister", FirstPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedLegIssuer", _wrap_new_EncodedLegIssuer, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedLegIssuer", _wrap_delete_EncodedLegIssuer, METH_VARARGS, NULL},
	 { (char *)"EncodedLegIssuer_swigregister", EncodedLegIssuer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AssignmentMethod", _wrap_new_AssignmentMethod, METH_VARARGS, NULL},
	 { (char *)"delete_AssignmentMethod", _wrap_delete_AssignmentMethod, METH_VARARGS, NULL},
	 { (char *)"AssignmentMethod_swigregister", AssignmentMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RoutingID", _wrap_new_RoutingID, METH_VARARGS, NULL},
	 { (char *)"delete_RoutingID", _wrap_delete_RoutingID, METH_VARARGS, NULL},
	 { (char *)"RoutingID_swigregister", RoutingID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StrategyParameterType", _wrap_new_StrategyParameterType, METH_VARARGS, NULL},
	 { (char *)"delete_StrategyParameterType", _wrap_delete_StrategyParameterType, METH_VARARGS, NULL},
	 { (char *)"StrategyParameterType_swigregister", StrategyParameterType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncryptMethod", _wrap_new_EncryptMethod, METH_VARARGS, NULL},
	 { (char *)"delete_EncryptMethod", _wrap_delete_EncryptMethod, METH_VARARGS, NULL},
	 { (char *)"EncryptMethod_swigregister", EncryptMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingStateOrProvinceOfIssue", _wrap_new_UnderlyingStateOrProvinceOfIssue, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingStateOrProvinceOfIssue", _wrap_delete_UnderlyingStateOrProvinceOfIssue, METH_VARARGS, NULL},
	 { (char *)"UnderlyingStateOrProvinceOfIssue_swigregister", UnderlyingStateOrProvinceOfIssue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplNewSeqNum", _wrap_new_ApplNewSeqNum, METH_VARARGS, NULL},
	 { (char *)"delete_ApplNewSeqNum", _wrap_delete_ApplNewSeqNum, METH_VARARGS, NULL},
	 { (char *)"ApplNewSeqNum_swigregister", ApplNewSeqNum_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeEncodedSecurityDescLen", _wrap_new_DerivativeEncodedSecurityDescLen, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeEncodedSecurityDescLen", _wrap_delete_DerivativeEncodedSecurityDescLen, METH_VARARGS, NULL},
	 { (char *)"DerivativeEncodedSecurityDescLen_swigregister", DerivativeEncodedSecurityDescLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradingCurrency", _wrap_new_TradingCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_TradingCurrency", _wrap_delete_TradingCurrency, METH_VARARGS, NULL},
	 { (char *)"TradingCurrency_swigregister", TradingCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryHighLimitPrice", _wrap_new_SecondaryHighLimitPrice, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryHighLimitPrice", _wrap_delete_SecondaryHighLimitPrice, METH_VARARGS, NULL},
	 { (char *)"SecondaryHighLimitPrice_swigregister", SecondaryHighLimitPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrderAvgPx", _wrap_new_OrderAvgPx, METH_VARARGS, NULL},
	 { (char *)"delete_OrderAvgPx", _wrap_delete_OrderAvgPx, METH_VARARGS, NULL},
	 { (char *)"OrderAvgPx_swigregister", OrderAvgPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PosAmtType", _wrap_new_PosAmtType, METH_VARARGS, NULL},
	 { (char *)"delete_PosAmtType", _wrap_delete_PosAmtType, METH_VARARGS, NULL},
	 { (char *)"PosAmtType_swigregister", PosAmtType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResetSeqNumFlag", _wrap_new_ResetSeqNumFlag, METH_VARARGS, NULL},
	 { (char *)"delete_ResetSeqNumFlag", _wrap_delete_ResetSeqNumFlag, METH_VARARGS, NULL},
	 { (char *)"ResetSeqNumFlag_swigregister", ResetSeqNumFlag_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoHops", _wrap_new_NoHops, METH_VARARGS, NULL},
	 { (char *)"delete_NoHops", _wrap_delete_NoHops, METH_VARARGS, NULL},
	 { (char *)"NoHops_swigregister", NoHops_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollInquiryResult", _wrap_new_CollInquiryResult, METH_VARARGS, NULL},
	 { (char *)"delete_CollInquiryResult", _wrap_delete_CollInquiryResult, METH_VARARGS, NULL},
	 { (char *)"CollInquiryResult_swigregister", CollInquiryResult_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StartDate", _wrap_new_StartDate, METH_VARARGS, NULL},
	 { (char *)"delete_StartDate", _wrap_delete_StartDate, METH_VARARGS, NULL},
	 { (char *)"StartDate_swigregister", StartDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollAsgnRespType", _wrap_new_CollAsgnRespType, METH_VARARGS, NULL},
	 { (char *)"delete_CollAsgnRespType", _wrap_delete_CollAsgnRespType, METH_VARARGS, NULL},
	 { (char *)"CollAsgnRespType_swigregister", CollAsgnRespType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrderBookingQty", _wrap_new_OrderBookingQty, METH_VARARGS, NULL},
	 { (char *)"delete_OrderBookingQty", _wrap_delete_OrderBookingQty, METH_VARARGS, NULL},
	 { (char *)"OrderBookingQty_swigregister", OrderBookingQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoQuoteQualifiers", _wrap_new_NoQuoteQualifiers, METH_VARARGS, NULL},
	 { (char *)"delete_NoQuoteQualifiers", _wrap_delete_NoQuoteQualifiers, METH_VARARGS, NULL},
	 { (char *)"NoQuoteQualifiers_swigregister", NoQuoteQualifiers_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnsolicitedIndicator", _wrap_new_UnsolicitedIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_UnsolicitedIndicator", _wrap_delete_UnsolicitedIndicator, METH_VARARGS, NULL},
	 { (char *)"UnsolicitedIndicator_swigregister", UnsolicitedIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefCstmApplVerID", _wrap_new_RefCstmApplVerID, METH_VARARGS, NULL},
	 { (char *)"delete_RefCstmApplVerID", _wrap_delete_RefCstmApplVerID, METH_VARARGS, NULL},
	 { (char *)"RefCstmApplVerID_swigregister", RefCstmApplVerID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideExecID", _wrap_new_SideExecID, METH_VARARGS, NULL},
	 { (char *)"delete_SideExecID", _wrap_delete_SideExecID, METH_VARARGS, NULL},
	 { (char *)"SideExecID_swigregister", SideExecID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RejectText", _wrap_new_RejectText, METH_VARARGS, NULL},
	 { (char *)"delete_RejectText", _wrap_delete_RejectText, METH_VARARGS, NULL},
	 { (char *)"RejectText_swigregister", RejectText_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExchangeSpecialInstructions", _wrap_new_ExchangeSpecialInstructions, METH_VARARGS, NULL},
	 { (char *)"delete_ExchangeSpecialInstructions", _wrap_delete_ExchangeSpecialInstructions, METH_VARARGS, NULL},
	 { (char *)"ExchangeSpecialInstructions_swigregister", ExchangeSpecialInstructions_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeID", _wrap_new_TradeID, METH_VARARGS, NULL},
	 { (char *)"delete_TradeID", _wrap_delete_TradeID, METH_VARARGS, NULL},
	 { (char *)"TradeID_swigregister", TradeID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RndPx", _wrap_new_RndPx, METH_VARARGS, NULL},
	 { (char *)"delete_RndPx", _wrap_delete_RndPx, METH_VARARGS, NULL},
	 { (char *)"RndPx_swigregister", RndPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteEntryRejectReason", _wrap_new_QuoteEntryRejectReason, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteEntryRejectReason", _wrap_delete_QuoteEntryRejectReason, METH_VARARGS, NULL},
	 { (char *)"QuoteEntryRejectReason_swigregister", QuoteEntryRejectReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrderCapacity", _wrap_new_OrderCapacity, METH_VARARGS, NULL},
	 { (char *)"delete_OrderCapacity", _wrap_delete_OrderCapacity, METH_VARARGS, NULL},
	 { (char *)"OrderCapacity_swigregister", OrderCapacity_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideLastQty", _wrap_new_SideLastQty, METH_VARARGS, NULL},
	 { (char *)"delete_SideLastQty", _wrap_delete_SideLastQty, METH_VARARGS, NULL},
	 { (char *)"SideLastQty_swigregister", SideLastQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeUnitOfMeasure", _wrap_new_DerivativeUnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeUnitOfMeasure", _wrap_delete_DerivativeUnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"DerivativeUnitOfMeasure_swigregister", DerivativeUnitOfMeasure_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoLegAllocs", _wrap_new_NoLegAllocs, METH_VARARGS, NULL},
	 { (char *)"delete_NoLegAllocs", _wrap_delete_NoLegAllocs, METH_VARARGS, NULL},
	 { (char *)"NoLegAllocs_swigregister", NoLegAllocs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteAckStatus", _wrap_new_QuoteAckStatus, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteAckStatus", _wrap_delete_QuoteAckStatus, METH_VARARGS, NULL},
	 { (char *)"QuoteAckStatus_swigregister", QuoteAckStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryFirmTradeID", _wrap_new_SecondaryFirmTradeID, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryFirmTradeID", _wrap_delete_SecondaryFirmTradeID, METH_VARARGS, NULL},
	 { (char *)"SecondaryFirmTradeID_swigregister", SecondaryFirmTradeID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UserRequestType", _wrap_new_UserRequestType, METH_VARARGS, NULL},
	 { (char *)"delete_UserRequestType", _wrap_delete_UserRequestType, METH_VARARGS, NULL},
	 { (char *)"UserRequestType_swigregister", UserRequestType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryTrdType", _wrap_new_SecondaryTrdType, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryTrdType", _wrap_delete_SecondaryTrdType, METH_VARARGS, NULL},
	 { (char *)"SecondaryTrdType_swigregister", SecondaryTrdType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeReportTransType", _wrap_new_TradeReportTransType, METH_VARARGS, NULL},
	 { (char *)"delete_TradeReportTransType", _wrap_delete_TradeReportTransType, METH_VARARGS, NULL},
	 { (char *)"TradeReportTransType_swigregister", TradeReportTransType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AdvSide", _wrap_new_AdvSide, METH_VARARGS, NULL},
	 { (char *)"delete_AdvSide", _wrap_delete_AdvSide, METH_VARARGS, NULL},
	 { (char *)"AdvSide_swigregister", AdvSide_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSecuritySubType", _wrap_new_DerivativeSecuritySubType, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSecuritySubType", _wrap_delete_DerivativeSecuritySubType, METH_VARARGS, NULL},
	 { (char *)"DerivativeSecuritySubType_swigregister", DerivativeSecuritySubType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerTradingSessionSubID", _wrap_new_TriggerTradingSessionSubID, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerTradingSessionSubID", _wrap_delete_TriggerTradingSessionSubID, METH_VARARGS, NULL},
	 { (char *)"TriggerTradingSessionSubID_swigregister", TriggerTradingSessionSubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeLinkID", _wrap_new_TradeLinkID, METH_VARARGS, NULL},
	 { (char *)"delete_TradeLinkID", _wrap_delete_TradeLinkID, METH_VARARGS, NULL},
	 { (char *)"TradeLinkID_swigregister", TradeLinkID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegBenchmarkPrice", _wrap_new_LegBenchmarkPrice, METH_VARARGS, NULL},
	 { (char *)"delete_LegBenchmarkPrice", _wrap_delete_LegBenchmarkPrice, METH_VARARGS, NULL},
	 { (char *)"LegBenchmarkPrice_swigregister", LegBenchmarkPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HopRefID", _wrap_new_HopRefID, METH_VARARGS, NULL},
	 { (char *)"delete_HopRefID", _wrap_delete_HopRefID, METH_VARARGS, NULL},
	 { (char *)"HopRefID_swigregister", HopRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Designation", _wrap_new_Designation, METH_VARARGS, NULL},
	 { (char *)"delete_Designation", _wrap_delete_Designation, METH_VARARGS, NULL},
	 { (char *)"Designation_swigregister", Designation_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeRequestID", _wrap_new_TradeRequestID, METH_VARARGS, NULL},
	 { (char *)"delete_TradeRequestID", _wrap_delete_TradeRequestID, METH_VARARGS, NULL},
	 { (char *)"TradeRequestID_swigregister", TradeRequestID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegFlowScheduleType", _wrap_new_LegFlowScheduleType, METH_VARARGS, NULL},
	 { (char *)"delete_LegFlowScheduleType", _wrap_delete_LegFlowScheduleType, METH_VARARGS, NULL},
	 { (char *)"LegFlowScheduleType_swigregister", LegFlowScheduleType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegPriceUnitOfMeasure", _wrap_new_LegPriceUnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"delete_LegPriceUnitOfMeasure", _wrap_delete_LegPriceUnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"LegPriceUnitOfMeasure_swigregister", LegPriceUnitOfMeasure_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested4PartyIDSource", _wrap_new_Nested4PartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_Nested4PartyIDSource", _wrap_delete_Nested4PartyIDSource, METH_VARARGS, NULL},
	 { (char *)"Nested4PartyIDSource_swigregister", Nested4PartyIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CoveredOrUncovered", _wrap_new_CoveredOrUncovered, METH_VARARGS, NULL},
	 { (char *)"delete_CoveredOrUncovered", _wrap_delete_CoveredOrUncovered, METH_VARARGS, NULL},
	 { (char *)"CoveredOrUncovered_swigregister", CoveredOrUncovered_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AcctIDSource", _wrap_new_AcctIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_AcctIDSource", _wrap_delete_AcctIDSource, METH_VARARGS, NULL},
	 { (char *)"AcctIDSource_swigregister", AcctIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MktOfferPx", _wrap_new_MktOfferPx, METH_VARARGS, NULL},
	 { (char *)"delete_MktOfferPx", _wrap_delete_MktOfferPx, METH_VARARGS, NULL},
	 { (char *)"MktOfferPx_swigregister", MktOfferPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoCapacities", _wrap_new_NoCapacities, METH_VARARGS, NULL},
	 { (char *)"delete_NoCapacities", _wrap_delete_NoCapacities, METH_VARARGS, NULL},
	 { (char *)"NoCapacities_swigregister", NoCapacities_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeRequestType", _wrap_new_TradeRequestType, METH_VARARGS, NULL},
	 { (char *)"delete_TradeRequestType", _wrap_delete_TradeRequestType, METH_VARARGS, NULL},
	 { (char *)"TradeRequestType_swigregister", TradeRequestType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoNestedPartyIDs", _wrap_new_NoNestedPartyIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoNestedPartyIDs", _wrap_delete_NoNestedPartyIDs, METH_VARARGS, NULL},
	 { (char *)"NoNestedPartyIDs_swigregister", NoNestedPartyIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradSesStatus", _wrap_new_TradSesStatus, METH_VARARGS, NULL},
	 { (char *)"delete_TradSesStatus", _wrap_delete_TradSesStatus, METH_VARARGS, NULL},
	 { (char *)"TradSesStatus_swigregister", TradSesStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingNotionalPercentageOutstanding", _wrap_new_UnderlyingNotionalPercentageOutstanding, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingNotionalPercentageOutstanding", _wrap_delete_UnderlyingNotionalPercentageOutstanding, METH_VARARGS, NULL},
	 { (char *)"UnderlyingNotionalPercentageOutstanding_swigregister", UnderlyingNotionalPercentageOutstanding_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplLastSeqNum", _wrap_new_ApplLastSeqNum, METH_VARARGS, NULL},
	 { (char *)"delete_ApplLastSeqNum", _wrap_delete_ApplLastSeqNum, METH_VARARGS, NULL},
	 { (char *)"ApplLastSeqNum_swigregister", ApplLastSeqNum_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PegPriceType", _wrap_new_PegPriceType, METH_VARARGS, NULL},
	 { (char *)"delete_PegPriceType", _wrap_delete_PegPriceType, METH_VARARGS, NULL},
	 { (char *)"PegPriceType_swigregister", PegPriceType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StrategyParameterName", _wrap_new_StrategyParameterName, METH_VARARGS, NULL},
	 { (char *)"delete_StrategyParameterName", _wrap_delete_StrategyParameterName, METH_VARARGS, NULL},
	 { (char *)"StrategyParameterName_swigregister", StrategyParameterName_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StreamAsgnRejReason", _wrap_new_StreamAsgnRejReason, METH_VARARGS, NULL},
	 { (char *)"delete_StreamAsgnRejReason", _wrap_delete_StreamAsgnRejReason, METH_VARARGS, NULL},
	 { (char *)"StreamAsgnRejReason_swigregister", StreamAsgnRejReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MatchIncrement", _wrap_new_MatchIncrement, METH_VARARGS, NULL},
	 { (char *)"delete_MatchIncrement", _wrap_delete_MatchIncrement, METH_VARARGS, NULL},
	 { (char *)"MatchIncrement_swigregister", MatchIncrement_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested3PartyRole", _wrap_new_Nested3PartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_Nested3PartyRole", _wrap_delete_Nested3PartyRole, METH_VARARGS, NULL},
	 { (char *)"Nested3PartyRole_swigregister", Nested3PartyRole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingPx", _wrap_new_UnderlyingPx, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingPx", _wrap_delete_UnderlyingPx, METH_VARARGS, NULL},
	 { (char *)"UnderlyingPx_swigregister", UnderlyingPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PriceImprovement", _wrap_new_PriceImprovement, METH_VARARGS, NULL},
	 { (char *)"delete_PriceImprovement", _wrap_delete_PriceImprovement, METH_VARARGS, NULL},
	 { (char *)"PriceImprovement_swigregister", PriceImprovement_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ValuationMethod", _wrap_new_ValuationMethod, METH_VARARGS, NULL},
	 { (char *)"delete_ValuationMethod", _wrap_delete_ValuationMethod, METH_VARARGS, NULL},
	 { (char *)"ValuationMethod_swigregister", ValuationMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSecurityID", _wrap_new_DerivativeSecurityID, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSecurityID", _wrap_delete_DerivativeSecurityID, METH_VARARGS, NULL},
	 { (char *)"DerivativeSecurityID_swigregister", DerivativeSecurityID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoExpiration", _wrap_new_NoExpiration, METH_VARARGS, NULL},
	 { (char *)"delete_NoExpiration", _wrap_delete_NoExpiration, METH_VARARGS, NULL},
	 { (char *)"NoExpiration_swigregister", NoExpiration_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TargetCompID", _wrap_new_TargetCompID, METH_VARARGS, NULL},
	 { (char *)"delete_TargetCompID", _wrap_delete_TargetCompID, METH_VARARGS, NULL},
	 { (char *)"TargetCompID_swigregister", TargetCompID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDEntryBuyer", _wrap_new_MDEntryBuyer, METH_VARARGS, NULL},
	 { (char *)"delete_MDEntryBuyer", _wrap_delete_MDEntryBuyer, METH_VARARGS, NULL},
	 { (char *)"MDEntryBuyer_swigregister", MDEntryBuyer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoDerivativeInstrumentPartySubIDs", _wrap_new_NoDerivativeInstrumentPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoDerivativeInstrumentPartySubIDs", _wrap_delete_NoDerivativeInstrumentPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"NoDerivativeInstrumentPartySubIDs_swigregister", NoDerivativeInstrumentPartySubIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoMaturityRules", _wrap_new_NoMaturityRules, METH_VARARGS, NULL},
	 { (char *)"delete_NoMaturityRules", _wrap_delete_NoMaturityRules, METH_VARARGS, NULL},
	 { (char *)"NoMaturityRules_swigregister", NoMaturityRules_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteMsgID", _wrap_new_QuoteMsgID, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteMsgID", _wrap_delete_QuoteMsgID, METH_VARARGS, NULL},
	 { (char *)"QuoteMsgID_swigregister", QuoteMsgID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerType", _wrap_new_TriggerType, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerType", _wrap_delete_TriggerType, METH_VARARGS, NULL},
	 { (char *)"TriggerType_swigregister", TriggerType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PriceProtectionScope", _wrap_new_PriceProtectionScope, METH_VARARGS, NULL},
	 { (char *)"delete_PriceProtectionScope", _wrap_delete_PriceProtectionScope, METH_VARARGS, NULL},
	 { (char *)"PriceProtectionScope_swigregister", PriceProtectionScope_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotNumAssignmentReports", _wrap_new_TotNumAssignmentReports, METH_VARARGS, NULL},
	 { (char *)"delete_TotNumAssignmentReports", _wrap_delete_TotNumAssignmentReports, METH_VARARGS, NULL},
	 { (char *)"TotNumAssignmentReports_swigregister", TotNumAssignmentReports_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ContraLegRefID", _wrap_new_ContraLegRefID, METH_VARARGS, NULL},
	 { (char *)"delete_ContraLegRefID", _wrap_delete_ContraLegRefID, METH_VARARGS, NULL},
	 { (char *)"ContraLegRefID_swigregister", ContraLegRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeReportRejectReason", _wrap_new_TradeReportRejectReason, METH_VARARGS, NULL},
	 { (char *)"delete_TradeReportRejectReason", _wrap_delete_TradeReportRejectReason, METH_VARARGS, NULL},
	 { (char *)"TradeReportRejectReason_swigregister", TradeReportRejectReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeReportRefID", _wrap_new_TradeReportRefID, METH_VARARGS, NULL},
	 { (char *)"delete_TradeReportRefID", _wrap_delete_TradeReportRefID, METH_VARARGS, NULL},
	 { (char *)"TradeReportRefID_swigregister", TradeReportRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityListType", _wrap_new_SecurityListType, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityListType", _wrap_delete_SecurityListType, METH_VARARGS, NULL},
	 { (char *)"SecurityListType_swigregister", SecurityListType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSecurityIDSource", _wrap_new_DerivativeSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSecurityIDSource", _wrap_delete_DerivativeSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"DerivativeSecurityIDSource_swigregister", DerivativeSecurityIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AssignmentUnit", _wrap_new_AssignmentUnit, METH_VARARGS, NULL},
	 { (char *)"delete_AssignmentUnit", _wrap_delete_AssignmentUnit, METH_VARARGS, NULL},
	 { (char *)"AssignmentUnit_swigregister", AssignmentUnit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeReportID", _wrap_new_TradeReportID, METH_VARARGS, NULL},
	 { (char *)"delete_TradeReportID", _wrap_delete_TradeReportID, METH_VARARGS, NULL},
	 { (char *)"TradeReportID_swigregister", TradeReportID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoRpts", _wrap_new_NoRpts, METH_VARARGS, NULL},
	 { (char *)"delete_NoRpts", _wrap_delete_NoRpts, METH_VARARGS, NULL},
	 { (char *)"NoRpts_swigregister", NoRpts_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegBenchmarkPriceType", _wrap_new_LegBenchmarkPriceType, METH_VARARGS, NULL},
	 { (char *)"delete_LegBenchmarkPriceType", _wrap_delete_LegBenchmarkPriceType, METH_VARARGS, NULL},
	 { (char *)"LegBenchmarkPriceType_swigregister", LegBenchmarkPriceType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedSubjectLen", _wrap_new_EncodedSubjectLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedSubjectLen", _wrap_delete_EncodedSubjectLen, METH_VARARGS, NULL},
	 { (char *)"EncodedSubjectLen_swigregister", EncodedSubjectLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityXML", _wrap_new_SecurityXML, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityXML", _wrap_delete_SecurityXML, METH_VARARGS, NULL},
	 { (char *)"SecurityXML_swigregister", SecurityXML_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegReportID", _wrap_new_LegReportID, METH_VARARGS, NULL},
	 { (char *)"delete_LegReportID", _wrap_delete_LegReportID, METH_VARARGS, NULL},
	 { (char *)"LegReportID_swigregister", LegReportID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested3PartySubIDType", _wrap_new_Nested3PartySubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_Nested3PartySubIDType", _wrap_delete_Nested3PartySubIDType, METH_VARARGS, NULL},
	 { (char *)"Nested3PartySubIDType_swigregister", Nested3PartySubIDType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BenchmarkSecurityIDSource", _wrap_new_BenchmarkSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_BenchmarkSecurityIDSource", _wrap_delete_BenchmarkSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"BenchmarkSecurityIDSource_swigregister", BenchmarkSecurityIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteRejectReason", _wrap_new_QuoteRejectReason, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteRejectReason", _wrap_delete_QuoteRejectReason, METH_VARARGS, NULL},
	 { (char *)"QuoteRejectReason_swigregister", QuoteRejectReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HeartBtInt", _wrap_new_HeartBtInt, METH_VARARGS, NULL},
	 { (char *)"delete_HeartBtInt", _wrap_delete_HeartBtInt, METH_VARARGS, NULL},
	 { (char *)"HeartBtInt_swigregister", HeartBtInt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BidForwardPoints", _wrap_new_BidForwardPoints, METH_VARARGS, NULL},
	 { (char *)"delete_BidForwardPoints", _wrap_delete_BidForwardPoints, METH_VARARGS, NULL},
	 { (char *)"BidForwardPoints_swigregister", BidForwardPoints_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PossResend", _wrap_new_PossResend, METH_VARARGS, NULL},
	 { (char *)"delete_PossResend", _wrap_delete_PossResend, METH_VARARGS, NULL},
	 { (char *)"PossResend_swigregister", PossResend_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Symbol", _wrap_new_Symbol, METH_VARARGS, NULL},
	 { (char *)"delete_Symbol", _wrap_delete_Symbol, METH_VARARGS, NULL},
	 { (char *)"Symbol_swigregister", Symbol_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedUnderlyingSecurityDesc", _wrap_new_EncodedUnderlyingSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedUnderlyingSecurityDesc", _wrap_delete_EncodedUnderlyingSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"EncodedUnderlyingSecurityDesc_swigregister", EncodedUnderlyingSecurityDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MarketReportID", _wrap_new_MarketReportID, METH_VARARGS, NULL},
	 { (char *)"delete_MarketReportID", _wrap_delete_MarketReportID, METH_VARARGS, NULL},
	 { (char *)"MarketReportID_swigregister", MarketReportID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DiscretionPrice", _wrap_new_DiscretionPrice, METH_VARARGS, NULL},
	 { (char *)"delete_DiscretionPrice", _wrap_delete_DiscretionPrice, METH_VARARGS, NULL},
	 { (char *)"DiscretionPrice_swigregister", DiscretionPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ContAmtValue", _wrap_new_ContAmtValue, METH_VARARGS, NULL},
	 { (char *)"delete_ContAmtValue", _wrap_delete_ContAmtValue, METH_VARARGS, NULL},
	 { (char *)"ContAmtValue_swigregister", ContAmtValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuantityType", _wrap_new_QuantityType, METH_VARARGS, NULL},
	 { (char *)"delete_QuantityType", _wrap_delete_QuantityType, METH_VARARGS, NULL},
	 { (char *)"QuantityType_swigregister", QuantityType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ComplexEventPriceBoundaryMethod", _wrap_new_ComplexEventPriceBoundaryMethod, METH_VARARGS, NULL},
	 { (char *)"delete_ComplexEventPriceBoundaryMethod", _wrap_delete_ComplexEventPriceBoundaryMethod, METH_VARARGS, NULL},
	 { (char *)"ComplexEventPriceBoundaryMethod_swigregister", ComplexEventPriceBoundaryMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ImpliedMarketIndicator", _wrap_new_ImpliedMarketIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_ImpliedMarketIndicator", _wrap_delete_ImpliedMarketIndicator, METH_VARARGS, NULL},
	 { (char *)"ImpliedMarketIndicator_swigregister", ImpliedMarketIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocClearingFeeIndicator", _wrap_new_AllocClearingFeeIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_AllocClearingFeeIndicator", _wrap_delete_AllocClearingFeeIndicator, METH_VARARGS, NULL},
	 { (char *)"AllocClearingFeeIndicator_swigregister", AllocClearingFeeIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteRequestType", _wrap_new_QuoteRequestType, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteRequestType", _wrap_delete_QuoteRequestType, METH_VARARGS, NULL},
	 { (char *)"QuoteRequestType_swigregister", QuoteRequestType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityRequestResult", _wrap_new_SecurityRequestResult, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityRequestResult", _wrap_delete_SecurityRequestResult, METH_VARARGS, NULL},
	 { (char *)"SecurityRequestResult_swigregister", SecurityRequestResult_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrderRestrictions", _wrap_new_OrderRestrictions, METH_VARARGS, NULL},
	 { (char *)"delete_OrderRestrictions", _wrap_delete_OrderRestrictions, METH_VARARGS, NULL},
	 { (char *)"OrderRestrictions_swigregister", OrderRestrictions_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoSideTrdRegTS", _wrap_new_NoSideTrdRegTS, METH_VARARGS, NULL},
	 { (char *)"delete_NoSideTrdRegTS", _wrap_delete_NoSideTrdRegTS, METH_VARARGS, NULL},
	 { (char *)"NoSideTrdRegTS_swigregister", NoSideTrdRegTS_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Text", _wrap_new_Text, METH_VARARGS, NULL},
	 { (char *)"delete_Text", _wrap_delete_Text, METH_VARARGS, NULL},
	 { (char *)"Text_swigregister", Text_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedTextLen", _wrap_new_EncodedTextLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedTextLen", _wrap_delete_EncodedTextLen, METH_VARARGS, NULL},
	 { (char *)"EncodedTextLen_swigregister", EncodedTextLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ListExecInstType", _wrap_new_ListExecInstType, METH_VARARGS, NULL},
	 { (char *)"delete_ListExecInstType", _wrap_delete_ListExecInstType, METH_VARARGS, NULL},
	 { (char *)"ListExecInstType_swigregister", ListExecInstType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryOrderID", _wrap_new_SecondaryOrderID, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryOrderID", _wrap_delete_SecondaryOrderID, METH_VARARGS, NULL},
	 { (char *)"SecondaryOrderID_swigregister", SecondaryOrderID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExecBroker", _wrap_new_ExecBroker, METH_VARARGS, NULL},
	 { (char *)"delete_ExecBroker", _wrap_delete_ExecBroker, METH_VARARGS, NULL},
	 { (char *)"ExecBroker_swigregister", ExecBroker_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityXMLLen", _wrap_new_SecurityXMLLen, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityXMLLen", _wrap_delete_SecurityXMLLen, METH_VARARGS, NULL},
	 { (char *)"SecurityXMLLen_swigregister", SecurityXMLLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplSeqNum", _wrap_new_ApplSeqNum, METH_VARARGS, NULL},
	 { (char *)"delete_ApplSeqNum", _wrap_delete_ApplSeqNum, METH_VARARGS, NULL},
	 { (char *)"ApplSeqNum_swigregister", ApplSeqNum_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaxTradeVol", _wrap_new_MaxTradeVol, METH_VARARGS, NULL},
	 { (char *)"delete_MaxTradeVol", _wrap_delete_MaxTradeVol, METH_VARARGS, NULL},
	 { (char *)"MaxTradeVol_swigregister", MaxTradeVol_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OfferSwapPoints", _wrap_new_OfferSwapPoints, METH_VARARGS, NULL},
	 { (char *)"delete_OfferSwapPoints", _wrap_delete_OfferSwapPoints, METH_VARARGS, NULL},
	 { (char *)"OfferSwapPoints_swigregister", OfferSwapPoints_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlPartySubIDType", _wrap_new_SettlPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_SettlPartySubIDType", _wrap_delete_SettlPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"SettlPartySubIDType_swigregister", SettlPartySubIDType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DistribPaymentMethod", _wrap_new_DistribPaymentMethod, METH_VARARGS, NULL},
	 { (char *)"delete_DistribPaymentMethod", _wrap_delete_DistribPaymentMethod, METH_VARARGS, NULL},
	 { (char *)"DistribPaymentMethod_swigregister", DistribPaymentMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotalAffectedOrders", _wrap_new_TotalAffectedOrders, METH_VARARGS, NULL},
	 { (char *)"delete_TotalAffectedOrders", _wrap_delete_TotalAffectedOrders, METH_VARARGS, NULL},
	 { (char *)"TotalAffectedOrders_swigregister", TotalAffectedOrders_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StrikeIncrement", _wrap_new_StrikeIncrement, METH_VARARGS, NULL},
	 { (char *)"delete_StrikeIncrement", _wrap_delete_StrikeIncrement, METH_VARARGS, NULL},
	 { (char *)"StrikeIncrement_swigregister", StrikeIncrement_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrderHandlingInstSource", _wrap_new_OrderHandlingInstSource, METH_VARARGS, NULL},
	 { (char *)"delete_OrderHandlingInstSource", _wrap_delete_OrderHandlingInstSource, METH_VARARGS, NULL},
	 { (char *)"OrderHandlingInstSource_swigregister", OrderHandlingInstSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CopyMsgIndicator", _wrap_new_CopyMsgIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_CopyMsgIndicator", _wrap_delete_CopyMsgIndicator, METH_VARARGS, NULL},
	 { (char *)"CopyMsgIndicator_swigregister", CopyMsgIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoDlvyInst", _wrap_new_NoDlvyInst, METH_VARARGS, NULL},
	 { (char *)"delete_NoDlvyInst", _wrap_delete_NoDlvyInst, METH_VARARGS, NULL},
	 { (char *)"NoDlvyInst_swigregister", NoDlvyInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteEntryID", _wrap_new_QuoteEntryID, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteEntryID", _wrap_delete_QuoteEntryID, METH_VARARGS, NULL},
	 { (char *)"QuoteEntryID_swigregister", QuoteEntryID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AffirmStatus", _wrap_new_AffirmStatus, METH_VARARGS, NULL},
	 { (char *)"delete_AffirmStatus", _wrap_delete_AffirmStatus, METH_VARARGS, NULL},
	 { (char *)"AffirmStatus_swigregister", AffirmStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MailingInst", _wrap_new_MailingInst, METH_VARARGS, NULL},
	 { (char *)"delete_MailingInst", _wrap_delete_MailingInst, METH_VARARGS, NULL},
	 { (char *)"MailingInst_swigregister", MailingInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OfferSize", _wrap_new_OfferSize, METH_VARARGS, NULL},
	 { (char *)"delete_OfferSize", _wrap_delete_OfferSize, METH_VARARGS, NULL},
	 { (char *)"OfferSize_swigregister", OfferSize_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSecurityType", _wrap_new_LegSecurityType, METH_VARARGS, NULL},
	 { (char *)"delete_LegSecurityType", _wrap_delete_LegSecurityType, METH_VARARGS, NULL},
	 { (char *)"LegSecurityType_swigregister", LegSecurityType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrigCustOrderCapacity", _wrap_new_OrigCustOrderCapacity, METH_VARARGS, NULL},
	 { (char *)"delete_OrigCustOrderCapacity", _wrap_delete_OrigCustOrderCapacity, METH_VARARGS, NULL},
	 { (char *)"OrigCustOrderCapacity_swigregister", OrigCustOrderCapacity_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocMethod", _wrap_new_AllocMethod, METH_VARARGS, NULL},
	 { (char *)"delete_AllocMethod", _wrap_delete_AllocMethod, METH_VARARGS, NULL},
	 { (char *)"AllocMethod_swigregister", AllocMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuantityDate", _wrap_new_QuantityDate, METH_VARARGS, NULL},
	 { (char *)"delete_QuantityDate", _wrap_delete_QuantityDate, METH_VARARGS, NULL},
	 { (char *)"QuantityDate_swigregister", QuantityDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TargetStrategyPerformance", _wrap_new_TargetStrategyPerformance, METH_VARARGS, NULL},
	 { (char *)"delete_TargetStrategyPerformance", _wrap_delete_TargetStrategyPerformance, METH_VARARGS, NULL},
	 { (char *)"TargetStrategyPerformance_swigregister", TargetStrategyPerformance_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CardExpDate", _wrap_new_CardExpDate, METH_VARARGS, NULL},
	 { (char *)"delete_CardExpDate", _wrap_delete_CardExpDate, METH_VARARGS, NULL},
	 { (char *)"CardExpDate_swigregister", CardExpDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ConfirmID", _wrap_new_ConfirmID, METH_VARARGS, NULL},
	 { (char *)"delete_ConfirmID", _wrap_delete_ConfirmID, METH_VARARGS, NULL},
	 { (char *)"ConfirmID_swigregister", ConfirmID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StandInstDbName", _wrap_new_StandInstDbName, METH_VARARGS, NULL},
	 { (char *)"delete_StandInstDbName", _wrap_delete_StandInstDbName, METH_VARARGS, NULL},
	 { (char *)"StandInstDbName_swigregister", StandInstDbName_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DayOrderQty", _wrap_new_DayOrderQty, METH_VARARGS, NULL},
	 { (char *)"delete_DayOrderQty", _wrap_delete_DayOrderQty, METH_VARARGS, NULL},
	 { (char *)"DayOrderQty_swigregister", DayOrderQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HighLimitPrice", _wrap_new_HighLimitPrice, METH_VARARGS, NULL},
	 { (char *)"delete_HighLimitPrice", _wrap_delete_HighLimitPrice, METH_VARARGS, NULL},
	 { (char *)"HighLimitPrice_swigregister", HighLimitPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FirmTradeID", _wrap_new_FirmTradeID, METH_VARARGS, NULL},
	 { (char *)"delete_FirmTradeID", _wrap_delete_FirmTradeID, METH_VARARGS, NULL},
	 { (char *)"FirmTradeID_swigregister", FirmTradeID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryIndividualAllocID", _wrap_new_SecondaryIndividualAllocID, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryIndividualAllocID", _wrap_delete_SecondaryIndividualAllocID, METH_VARARGS, NULL},
	 { (char *)"SecondaryIndividualAllocID_swigregister", SecondaryIndividualAllocID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AgreementDesc", _wrap_new_AgreementDesc, METH_VARARGS, NULL},
	 { (char *)"delete_AgreementDesc", _wrap_delete_AgreementDesc, METH_VARARGS, NULL},
	 { (char *)"AgreementDesc_swigregister", AgreementDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MassCancelResponse", _wrap_new_MassCancelResponse, METH_VARARGS, NULL},
	 { (char *)"delete_MassCancelResponse", _wrap_delete_MassCancelResponse, METH_VARARGS, NULL},
	 { (char *)"MassCancelResponse_swigregister", MassCancelResponse_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSettlCurrency", _wrap_new_LegSettlCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_LegSettlCurrency", _wrap_delete_LegSettlCurrency, METH_VARARGS, NULL},
	 { (char *)"LegSettlCurrency_swigregister", LegSettlCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Commission", _wrap_new_Commission, METH_VARARGS, NULL},
	 { (char *)"delete_Commission", _wrap_delete_Commission, METH_VARARGS, NULL},
	 { (char *)"Commission_swigregister", Commission_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StreamAsgnReqType", _wrap_new_StreamAsgnReqType, METH_VARARGS, NULL},
	 { (char *)"delete_StreamAsgnReqType", _wrap_delete_StreamAsgnReqType, METH_VARARGS, NULL},
	 { (char *)"StreamAsgnReqType_swigregister", StreamAsgnReqType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BidSwapPoints", _wrap_new_BidSwapPoints, METH_VARARGS, NULL},
	 { (char *)"delete_BidSwapPoints", _wrap_delete_BidSwapPoints, METH_VARARGS, NULL},
	 { (char *)"BidSwapPoints_swigregister", BidSwapPoints_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoSettlPartyIDs", _wrap_new_NoSettlPartyIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoSettlPartyIDs", _wrap_delete_NoSettlPartyIDs, METH_VARARGS, NULL},
	 { (char *)"NoSettlPartyIDs_swigregister", NoSettlPartyIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SymbolSfx", _wrap_new_SymbolSfx, METH_VARARGS, NULL},
	 { (char *)"delete_SymbolSfx", _wrap_delete_SymbolSfx, METH_VARARGS, NULL},
	 { (char *)"SymbolSfx_swigregister", SymbolSfx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BusinessRejectRefID", _wrap_new_BusinessRejectRefID, METH_VARARGS, NULL},
	 { (char *)"delete_BusinessRejectRefID", _wrap_delete_BusinessRejectRefID, METH_VARARGS, NULL},
	 { (char *)"BusinessRejectRefID_swigregister", BusinessRejectRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Price2", _wrap_new_Price2, METH_VARARGS, NULL},
	 { (char *)"delete_Price2", _wrap_delete_Price2, METH_VARARGS, NULL},
	 { (char *)"Price2_swigregister", Price2_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FillLiquidityInd", _wrap_new_FillLiquidityInd, METH_VARARGS, NULL},
	 { (char *)"delete_FillLiquidityInd", _wrap_delete_FillLiquidityInd, METH_VARARGS, NULL},
	 { (char *)"FillLiquidityInd_swigregister", FillLiquidityInd_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MassActionReportID", _wrap_new_MassActionReportID, METH_VARARGS, NULL},
	 { (char *)"delete_MassActionReportID", _wrap_delete_MassActionReportID, METH_VARARGS, NULL},
	 { (char *)"MassActionReportID_swigregister", MassActionReportID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeIssuer", _wrap_new_DerivativeIssuer, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeIssuer", _wrap_delete_DerivativeIssuer, METH_VARARGS, NULL},
	 { (char *)"DerivativeIssuer_swigregister", DerivativeIssuer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExDestinationIDSource", _wrap_new_ExDestinationIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_ExDestinationIDSource", _wrap_delete_ExDestinationIDSource, METH_VARARGS, NULL},
	 { (char *)"ExDestinationIDSource_swigregister", ExDestinationIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollRespID", _wrap_new_CollRespID, METH_VARARGS, NULL},
	 { (char *)"delete_CollRespID", _wrap_delete_CollRespID, METH_VARARGS, NULL},
	 { (char *)"CollRespID_swigregister", CollRespID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityListRequestType", _wrap_new_SecurityListRequestType, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityListRequestType", _wrap_delete_SecurityListRequestType, METH_VARARGS, NULL},
	 { (char *)"SecurityListRequestType_swigregister", SecurityListRequestType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedLegSecurityDesc", _wrap_new_EncodedLegSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedLegSecurityDesc", _wrap_delete_EncodedLegSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"EncodedLegSecurityDesc_swigregister", EncodedLegSecurityDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSettlementStatus", _wrap_new_UnderlyingSettlementStatus, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSettlementStatus", _wrap_delete_UnderlyingSettlementStatus, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSettlementStatus_swigregister", UnderlyingSettlementStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityAltID", _wrap_new_SecurityAltID, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityAltID", _wrap_delete_SecurityAltID, METH_VARARGS, NULL},
	 { (char *)"SecurityAltID_swigregister", SecurityAltID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RegistRefID", _wrap_new_RegistRefID, METH_VARARGS, NULL},
	 { (char *)"delete_RegistRefID", _wrap_delete_RegistRefID, METH_VARARGS, NULL},
	 { (char *)"RegistRefID_swigregister", RegistRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativePriceQuoteMethod", _wrap_new_DerivativePriceQuoteMethod, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativePriceQuoteMethod", _wrap_delete_DerivativePriceQuoteMethod, METH_VARARGS, NULL},
	 { (char *)"DerivativePriceQuoteMethod_swigregister", DerivativePriceQuoteMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrderDelay", _wrap_new_OrderDelay, METH_VARARGS, NULL},
	 { (char *)"delete_OrderDelay", _wrap_delete_OrderDelay, METH_VARARGS, NULL},
	 { (char *)"OrderDelay_swigregister", OrderDelay_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoNotAffectedOrders", _wrap_new_NoNotAffectedOrders, METH_VARARGS, NULL},
	 { (char *)"delete_NoNotAffectedOrders", _wrap_delete_NoNotAffectedOrders, METH_VARARGS, NULL},
	 { (char *)"NoNotAffectedOrders_swigregister", NoNotAffectedOrders_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested3PartyID", _wrap_new_Nested3PartyID, METH_VARARGS, NULL},
	 { (char *)"delete_Nested3PartyID", _wrap_delete_Nested3PartyID, METH_VARARGS, NULL},
	 { (char *)"Nested3PartyID_swigregister", Nested3PartyID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollAsgnReason", _wrap_new_CollAsgnReason, METH_VARARGS, NULL},
	 { (char *)"delete_CollAsgnReason", _wrap_delete_CollAsgnReason, METH_VARARGS, NULL},
	 { (char *)"CollAsgnReason_swigregister", CollAsgnReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotalVolumeTradedTime", _wrap_new_TotalVolumeTradedTime, METH_VARARGS, NULL},
	 { (char *)"delete_TotalVolumeTradedTime", _wrap_delete_TotalVolumeTradedTime, METH_VARARGS, NULL},
	 { (char *)"TotalVolumeTradedTime_swigregister", TotalVolumeTradedTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityExchange", _wrap_new_SecurityExchange, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityExchange", _wrap_delete_SecurityExchange, METH_VARARGS, NULL},
	 { (char *)"SecurityExchange_swigregister", SecurityExchange_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlPriceType", _wrap_new_SettlPriceType, METH_VARARGS, NULL},
	 { (char *)"delete_SettlPriceType", _wrap_delete_SettlPriceType, METH_VARARGS, NULL},
	 { (char *)"SettlPriceType_swigregister", SettlPriceType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnitOfMeasureQty", _wrap_new_UnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"delete_UnitOfMeasureQty", _wrap_delete_UnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"UnitOfMeasureQty_swigregister", UnitOfMeasureQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UserRequestID", _wrap_new_UserRequestID, METH_VARARGS, NULL},
	 { (char *)"delete_UserRequestID", _wrap_delete_UserRequestID, METH_VARARGS, NULL},
	 { (char *)"UserRequestID_swigregister", UserRequestID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastParPx", _wrap_new_LastParPx, METH_VARARGS, NULL},
	 { (char *)"delete_LastParPx", _wrap_delete_LastParPx, METH_VARARGS, NULL},
	 { (char *)"LastParPx_swigregister", LastParPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EndMaturityMonthYear", _wrap_new_EndMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"delete_EndMaturityMonthYear", _wrap_delete_EndMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"EndMaturityMonthYear_swigregister", EndMaturityMonthYear_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DealingCapacity", _wrap_new_DealingCapacity, METH_VARARGS, NULL},
	 { (char *)"delete_DealingCapacity", _wrap_delete_DealingCapacity, METH_VARARGS, NULL},
	 { (char *)"DealingCapacity_swigregister", DealingCapacity_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PrevClosePx", _wrap_new_PrevClosePx, METH_VARARGS, NULL},
	 { (char *)"delete_PrevClosePx", _wrap_delete_PrevClosePx, METH_VARARGS, NULL},
	 { (char *)"PrevClosePx_swigregister", PrevClosePx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeInputDevice", _wrap_new_TradeInputDevice, METH_VARARGS, NULL},
	 { (char *)"delete_TradeInputDevice", _wrap_delete_TradeInputDevice, METH_VARARGS, NULL},
	 { (char *)"TradeInputDevice_swigregister", TradeInputDevice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DayCumQty", _wrap_new_DayCumQty, METH_VARARGS, NULL},
	 { (char *)"delete_DayCumQty", _wrap_delete_DayCumQty, METH_VARARGS, NULL},
	 { (char *)"DayCumQty_swigregister", DayCumQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecuritySettlAgentAcctNum", _wrap_new_SecuritySettlAgentAcctNum, METH_VARARGS, NULL},
	 { (char *)"delete_SecuritySettlAgentAcctNum", _wrap_delete_SecuritySettlAgentAcctNum, METH_VARARGS, NULL},
	 { (char *)"SecuritySettlAgentAcctNum_swigregister", SecuritySettlAgentAcctNum_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegCurrency", _wrap_new_LegCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_LegCurrency", _wrap_delete_LegCurrency, METH_VARARGS, NULL},
	 { (char *)"LegCurrency_swigregister", LegCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncryptedNewPassword", _wrap_new_EncryptedNewPassword, METH_VARARGS, NULL},
	 { (char *)"delete_EncryptedNewPassword", _wrap_delete_EncryptedNewPassword, METH_VARARGS, NULL},
	 { (char *)"EncryptedNewPassword_swigregister", EncryptedNewPassword_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeMinPriceIncrementAmount", _wrap_new_DerivativeMinPriceIncrementAmount, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeMinPriceIncrementAmount", _wrap_delete_DerivativeMinPriceIncrementAmount, METH_VARARGS, NULL},
	 { (char *)"DerivativeMinPriceIncrementAmount_swigregister", DerivativeMinPriceIncrementAmount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoNested3PartySubIDs", _wrap_new_NoNested3PartySubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoNested3PartySubIDs", _wrap_delete_NoNested3PartySubIDs, METH_VARARGS, NULL},
	 { (char *)"NoNested3PartySubIDs_swigregister", NoNested3PartySubIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefSubID", _wrap_new_RefSubID, METH_VARARGS, NULL},
	 { (char *)"delete_RefSubID", _wrap_delete_RefSubID, METH_VARARGS, NULL},
	 { (char *)"RefSubID_swigregister", RefSubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlPartyRole", _wrap_new_SettlPartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_SettlPartyRole", _wrap_delete_SettlPartyRole, METH_VARARGS, NULL},
	 { (char *)"SettlPartyRole_swigregister", SettlPartyRole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashDistribAgentName", _wrap_new_CashDistribAgentName, METH_VARARGS, NULL},
	 { (char *)"delete_CashDistribAgentName", _wrap_delete_CashDistribAgentName, METH_VARARGS, NULL},
	 { (char *)"CashDistribAgentName_swigregister", CashDistribAgentName_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegContractMultiplier", _wrap_new_LegContractMultiplier, METH_VARARGS, NULL},
	 { (char *)"delete_LegContractMultiplier", _wrap_delete_LegContractMultiplier, METH_VARARGS, NULL},
	 { (char *)"LegContractMultiplier_swigregister", LegContractMultiplier_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ProgPeriodInterval", _wrap_new_ProgPeriodInterval, METH_VARARGS, NULL},
	 { (char *)"delete_ProgPeriodInterval", _wrap_delete_ProgPeriodInterval, METH_VARARGS, NULL},
	 { (char *)"ProgPeriodInterval_swigregister", ProgPeriodInterval_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSettlType", _wrap_new_LegSettlType, METH_VARARGS, NULL},
	 { (char *)"delete_LegSettlType", _wrap_delete_LegSettlType, METH_VARARGS, NULL},
	 { (char *)"LegSettlType_swigregister", LegSettlType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OnBehalfOfLocationID", _wrap_new_OnBehalfOfLocationID, METH_VARARGS, NULL},
	 { (char *)"delete_OnBehalfOfLocationID", _wrap_delete_OnBehalfOfLocationID, METH_VARARGS, NULL},
	 { (char *)"OnBehalfOfLocationID_swigregister", OnBehalfOfLocationID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OnBehalfOfSubID", _wrap_new_OnBehalfOfSubID, METH_VARARGS, NULL},
	 { (char *)"delete_OnBehalfOfSubID", _wrap_delete_OnBehalfOfSubID, METH_VARARGS, NULL},
	 { (char *)"OnBehalfOfSubID_swigregister", OnBehalfOfSubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ComplexEventEndTime", _wrap_new_ComplexEventEndTime, METH_VARARGS, NULL},
	 { (char *)"delete_ComplexEventEndTime", _wrap_delete_ComplexEventEndTime, METH_VARARGS, NULL},
	 { (char *)"ComplexEventEndTime_swigregister", ComplexEventEndTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RateSourceType", _wrap_new_RateSourceType, METH_VARARGS, NULL},
	 { (char *)"delete_RateSourceType", _wrap_delete_RateSourceType, METH_VARARGS, NULL},
	 { (char *)"RateSourceType_swigregister", RateSourceType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeStateOrProvinceOfIssue", _wrap_new_DerivativeStateOrProvinceOfIssue, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeStateOrProvinceOfIssue", _wrap_delete_DerivativeStateOrProvinceOfIssue, METH_VARARGS, NULL},
	 { (char *)"DerivativeStateOrProvinceOfIssue_swigregister", DerivativeStateOrProvinceOfIssue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeLegRefID", _wrap_new_TradeLegRefID, METH_VARARGS, NULL},
	 { (char *)"delete_TradeLegRefID", _wrap_delete_TradeLegRefID, METH_VARARGS, NULL},
	 { (char *)"TradeLegRefID_swigregister", TradeLegRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RelSymTransactTime", _wrap_new_RelSymTransactTime, METH_VARARGS, NULL},
	 { (char *)"delete_RelSymTransactTime", _wrap_delete_RelSymTransactTime, METH_VARARGS, NULL},
	 { (char *)"RelSymTransactTime_swigregister", RelSymTransactTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoComplexEventTimes", _wrap_new_NoComplexEventTimes, METH_VARARGS, NULL},
	 { (char *)"delete_NoComplexEventTimes", _wrap_delete_NoComplexEventTimes, METH_VARARGS, NULL},
	 { (char *)"NoComplexEventTimes_swigregister", NoComplexEventTimes_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegCalculatedCcyLastQty", _wrap_new_LegCalculatedCcyLastQty, METH_VARARGS, NULL},
	 { (char *)"delete_LegCalculatedCcyLastQty", _wrap_delete_LegCalculatedCcyLastQty, METH_VARARGS, NULL},
	 { (char *)"LegCalculatedCcyLastQty_swigregister", LegCalculatedCcyLastQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested3PartyIDSource", _wrap_new_Nested3PartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_Nested3PartyIDSource", _wrap_delete_Nested3PartyIDSource, METH_VARARGS, NULL},
	 { (char *)"Nested3PartyIDSource_swigregister", Nested3PartyIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DatedDate", _wrap_new_DatedDate, METH_VARARGS, NULL},
	 { (char *)"delete_DatedDate", _wrap_delete_DatedDate, METH_VARARGS, NULL},
	 { (char *)"DatedDate_swigregister", DatedDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlInstID", _wrap_new_SettlInstID, METH_VARARGS, NULL},
	 { (char *)"delete_SettlInstID", _wrap_delete_SettlInstID, METH_VARARGS, NULL},
	 { (char *)"SettlInstID_swigregister", SettlInstID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OpenInterest", _wrap_new_OpenInterest, METH_VARARGS, NULL},
	 { (char *)"delete_OpenInterest", _wrap_delete_OpenInterest, METH_VARARGS, NULL},
	 { (char *)"OpenInterest_swigregister", OpenInterest_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingContractMultiplier", _wrap_new_UnderlyingContractMultiplier, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingContractMultiplier", _wrap_delete_UnderlyingContractMultiplier, METH_VARARGS, NULL},
	 { (char *)"UnderlyingContractMultiplier_swigregister", UnderlyingContractMultiplier_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotQuoteEntries", _wrap_new_TotQuoteEntries, METH_VARARGS, NULL},
	 { (char *)"delete_TotQuoteEntries", _wrap_delete_TotQuoteEntries, METH_VARARGS, NULL},
	 { (char *)"TotQuoteEntries_swigregister", TotQuoteEntries_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotNoCxldQuotes", _wrap_new_TotNoCxldQuotes, METH_VARARGS, NULL},
	 { (char *)"delete_TotNoCxldQuotes", _wrap_delete_TotNoCxldQuotes, METH_VARARGS, NULL},
	 { (char *)"TotNoCxldQuotes_swigregister", TotNoCxldQuotes_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AggregatedBook", _wrap_new_AggregatedBook, METH_VARARGS, NULL},
	 { (char *)"delete_AggregatedBook", _wrap_delete_AggregatedBook, METH_VARARGS, NULL},
	 { (char *)"AggregatedBook_swigregister", AggregatedBook_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PaymentRef", _wrap_new_PaymentRef, METH_VARARGS, NULL},
	 { (char *)"delete_PaymentRef", _wrap_delete_PaymentRef, METH_VARARGS, NULL},
	 { (char *)"PaymentRef_swigregister", PaymentRef_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PaymentDate", _wrap_new_PaymentDate, METH_VARARGS, NULL},
	 { (char *)"delete_PaymentDate", _wrap_delete_PaymentDate, METH_VARARGS, NULL},
	 { (char *)"PaymentDate_swigregister", PaymentDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrderPercent", _wrap_new_OrderPercent, METH_VARARGS, NULL},
	 { (char *)"delete_OrderPercent", _wrap_delete_OrderPercent, METH_VARARGS, NULL},
	 { (char *)"OrderPercent_swigregister", OrderPercent_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PosQtyStatus", _wrap_new_PosQtyStatus, METH_VARARGS, NULL},
	 { (char *)"delete_PosQtyStatus", _wrap_delete_PosQtyStatus, METH_VARARGS, NULL},
	 { (char *)"PosQtyStatus_swigregister", PosQtyStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoNested4PartySubIDs", _wrap_new_NoNested4PartySubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoNested4PartySubIDs", _wrap_delete_NoNested4PartySubIDs, METH_VARARGS, NULL},
	 { (char *)"NoNested4PartySubIDs_swigregister", NoNested4PartySubIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PrivateQuote", _wrap_new_PrivateQuote, METH_VARARGS, NULL},
	 { (char *)"delete_PrivateQuote", _wrap_delete_PrivateQuote, METH_VARARGS, NULL},
	 { (char *)"PrivateQuote_swigregister", PrivateQuote_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryTradeID", _wrap_new_SecondaryTradeID, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryTradeID", _wrap_delete_SecondaryTradeID, METH_VARARGS, NULL},
	 { (char *)"SecondaryTradeID_swigregister", SecondaryTradeID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecuritySettlAgentContactPhone", _wrap_new_SecuritySettlAgentContactPhone, METH_VARARGS, NULL},
	 { (char *)"delete_SecuritySettlAgentContactPhone", _wrap_delete_SecuritySettlAgentContactPhone, METH_VARARGS, NULL},
	 { (char *)"SecuritySettlAgentContactPhone_swigregister", SecuritySettlAgentContactPhone_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedMktSegmDescLen", _wrap_new_EncodedMktSegmDescLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedMktSegmDescLen", _wrap_delete_EncodedMktSegmDescLen, METH_VARARGS, NULL},
	 { (char *)"EncodedMktSegmDescLen_swigregister", EncodedMktSegmDescLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideCurrency", _wrap_new_SideCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_SideCurrency", _wrap_delete_SideCurrency, METH_VARARGS, NULL},
	 { (char *)"SideCurrency_swigregister", SideCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegQty", _wrap_new_LegQty, METH_VARARGS, NULL},
	 { (char *)"delete_LegQty", _wrap_delete_LegQty, METH_VARARGS, NULL},
	 { (char *)"LegQty_swigregister", LegQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MsgType", _wrap_new_MsgType, METH_VARARGS, NULL},
	 { (char *)"delete_MsgType", _wrap_delete_MsgType, METH_VARARGS, NULL},
	 { (char *)"MsgType_swigregister", MsgType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoTradingSessions", _wrap_new_NoTradingSessions, METH_VARARGS, NULL},
	 { (char *)"delete_NoTradingSessions", _wrap_delete_NoTradingSessions, METH_VARARGS, NULL},
	 { (char *)"NoTradingSessions_swigregister", NoTradingSessions_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IOIid", _wrap_new_IOIid, METH_VARARGS, NULL},
	 { (char *)"delete_IOIid", _wrap_delete_IOIid, METH_VARARGS, NULL},
	 { (char *)"IOIid_swigregister", IOIid_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MultiLegReportingType", _wrap_new_MultiLegReportingType, METH_VARARGS, NULL},
	 { (char *)"delete_MultiLegReportingType", _wrap_delete_MultiLegReportingType, METH_VARARGS, NULL},
	 { (char *)"MultiLegReportingType_swigregister", MultiLegReportingType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IDSource", _wrap_new_IDSource, METH_VARARGS, NULL},
	 { (char *)"delete_IDSource", _wrap_delete_IDSource, METH_VARARGS, NULL},
	 { (char *)"IDSource_swigregister", IDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegStipulationType", _wrap_new_LegStipulationType, METH_VARARGS, NULL},
	 { (char *)"delete_LegStipulationType", _wrap_delete_LegStipulationType, METH_VARARGS, NULL},
	 { (char *)"LegStipulationType_swigregister", LegStipulationType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeContractMultiplierUnit", _wrap_new_DerivativeContractMultiplierUnit, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeContractMultiplierUnit", _wrap_delete_DerivativeContractMultiplierUnit, METH_VARARGS, NULL},
	 { (char *)"DerivativeContractMultiplierUnit_swigregister", DerivativeContractMultiplierUnit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MarketSegmentID", _wrap_new_MarketSegmentID, METH_VARARGS, NULL},
	 { (char *)"delete_MarketSegmentID", _wrap_delete_MarketSegmentID, METH_VARARGS, NULL},
	 { (char *)"MarketSegmentID_swigregister", MarketSegmentID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrdStatus", _wrap_new_OrdStatus, METH_VARARGS, NULL},
	 { (char *)"delete_OrdStatus", _wrap_delete_OrdStatus, METH_VARARGS, NULL},
	 { (char *)"OrdStatus_swigregister", OrdStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaturityDate", _wrap_new_MaturityDate, METH_VARARGS, NULL},
	 { (char *)"delete_MaturityDate", _wrap_delete_MaturityDate, METH_VARARGS, NULL},
	 { (char *)"MaturityDate_swigregister", MaturityDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplTotalMessageCount", _wrap_new_ApplTotalMessageCount, METH_VARARGS, NULL},
	 { (char *)"delete_ApplTotalMessageCount", _wrap_delete_ApplTotalMessageCount, METH_VARARGS, NULL},
	 { (char *)"ApplTotalMessageCount_swigregister", ApplTotalMessageCount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InstrumentPartySubID", _wrap_new_InstrumentPartySubID, METH_VARARGS, NULL},
	 { (char *)"delete_InstrumentPartySubID", _wrap_delete_InstrumentPartySubID, METH_VARARGS, NULL},
	 { (char *)"InstrumentPartySubID_swigregister", InstrumentPartySubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CustomerOrFirm", _wrap_new_CustomerOrFirm, METH_VARARGS, NULL},
	 { (char *)"delete_CustomerOrFirm", _wrap_delete_CustomerOrFirm, METH_VARARGS, NULL},
	 { (char *)"CustomerOrFirm_swigregister", CustomerOrFirm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AdjustmentType", _wrap_new_AdjustmentType, METH_VARARGS, NULL},
	 { (char *)"delete_AdjustmentType", _wrap_delete_AdjustmentType, METH_VARARGS, NULL},
	 { (char *)"AdjustmentType_swigregister", AdjustmentType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingInstrumentPartyID", _wrap_new_UnderlyingInstrumentPartyID, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingInstrumentPartyID", _wrap_delete_UnderlyingInstrumentPartyID, METH_VARARGS, NULL},
	 { (char *)"UnderlyingInstrumentPartyID_swigregister", UnderlyingInstrumentPartyID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AsOfIndicator", _wrap_new_AsOfIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_AsOfIndicator", _wrap_delete_AsOfIndicator, METH_VARARGS, NULL},
	 { (char *)"AsOfIndicator_swigregister", AsOfIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteStatusReqID", _wrap_new_QuoteStatusReqID, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteStatusReqID", _wrap_delete_QuoteStatusReqID, METH_VARARGS, NULL},
	 { (char *)"QuoteStatusReqID_swigregister", QuoteStatusReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegPositionEffect", _wrap_new_LegPositionEffect, METH_VARARGS, NULL},
	 { (char *)"delete_LegPositionEffect", _wrap_delete_LegPositionEffect, METH_VARARGS, NULL},
	 { (char *)"LegPositionEffect_swigregister", LegPositionEffect_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDEntryPx", _wrap_new_MDEntryPx, METH_VARARGS, NULL},
	 { (char *)"delete_MDEntryPx", _wrap_delete_MDEntryPx, METH_VARARGS, NULL},
	 { (char *)"MDEntryPx_swigregister", MDEntryPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MassActionScope", _wrap_new_MassActionScope, METH_VARARGS, NULL},
	 { (char *)"delete_MassActionScope", _wrap_delete_MassActionScope, METH_VARARGS, NULL},
	 { (char *)"MassActionScope_swigregister", MassActionScope_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ReportedPxDiff", _wrap_new_ReportedPxDiff, METH_VARARGS, NULL},
	 { (char *)"delete_ReportedPxDiff", _wrap_delete_ReportedPxDiff, METH_VARARGS, NULL},
	 { (char *)"ReportedPxDiff_swigregister", ReportedPxDiff_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSettlementDate", _wrap_new_UnderlyingSettlementDate, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSettlementDate", _wrap_delete_UnderlyingSettlementDate, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSettlementDate_swigregister", UnderlyingSettlementDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoNestedPartySubIDs", _wrap_new_NoNestedPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoNestedPartySubIDs", _wrap_delete_NoNestedPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"NoNestedPartySubIDs_swigregister", NoNestedPartySubIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocReportRefID", _wrap_new_AllocReportRefID, METH_VARARGS, NULL},
	 { (char *)"delete_AllocReportRefID", _wrap_delete_AllocReportRefID, METH_VARARGS, NULL},
	 { (char *)"AllocReportRefID_swigregister", AllocReportRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Concession", _wrap_new_Concession, METH_VARARGS, NULL},
	 { (char *)"delete_Concession", _wrap_delete_Concession, METH_VARARGS, NULL},
	 { (char *)"Concession_swigregister", Concession_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedSecurityDesc", _wrap_new_EncodedSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedSecurityDesc", _wrap_delete_EncodedSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"EncodedSecurityDesc_swigregister", EncodedSecurityDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExecRefID", _wrap_new_ExecRefID, METH_VARARGS, NULL},
	 { (char *)"delete_ExecRefID", _wrap_delete_ExecRefID, METH_VARARGS, NULL},
	 { (char *)"ExecRefID_swigregister", ExecRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_VenueType", _wrap_new_VenueType, METH_VARARGS, NULL},
	 { (char *)"delete_VenueType", _wrap_delete_VenueType, METH_VARARGS, NULL},
	 { (char *)"VenueType_swigregister", VenueType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MassActionType", _wrap_new_MassActionType, METH_VARARGS, NULL},
	 { (char *)"delete_MassActionType", _wrap_delete_MassActionType, METH_VARARGS, NULL},
	 { (char *)"MassActionType_swigregister", MassActionType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PosMaintResult", _wrap_new_PosMaintResult, METH_VARARGS, NULL},
	 { (char *)"delete_PosMaintResult", _wrap_delete_PosMaintResult, METH_VARARGS, NULL},
	 { (char *)"PosMaintResult_swigregister", PosMaintResult_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IOIShares", _wrap_new_IOIShares, METH_VARARGS, NULL},
	 { (char *)"delete_IOIShares", _wrap_delete_IOIShares, METH_VARARGS, NULL},
	 { (char *)"IOIShares_swigregister", IOIShares_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BenchmarkSecurityID", _wrap_new_BenchmarkSecurityID, METH_VARARGS, NULL},
	 { (char *)"delete_BenchmarkSecurityID", _wrap_delete_BenchmarkSecurityID, METH_VARARGS, NULL},
	 { (char *)"BenchmarkSecurityID_swigregister", BenchmarkSecurityID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegLastQty", _wrap_new_LegLastQty, METH_VARARGS, NULL},
	 { (char *)"delete_LegLastQty", _wrap_delete_LegLastQty, METH_VARARGS, NULL},
	 { (char *)"LegLastQty_swigregister", LegLastQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocSettlCurrency", _wrap_new_AllocSettlCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_AllocSettlCurrency", _wrap_delete_AllocSettlCurrency, METH_VARARGS, NULL},
	 { (char *)"AllocSettlCurrency_swigregister", AllocSettlCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegCountryOfIssue", _wrap_new_LegCountryOfIssue, METH_VARARGS, NULL},
	 { (char *)"delete_LegCountryOfIssue", _wrap_delete_LegCountryOfIssue, METH_VARARGS, NULL},
	 { (char *)"LegCountryOfIssue_swigregister", LegCountryOfIssue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSecurityXML", _wrap_new_DerivativeSecurityXML, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSecurityXML", _wrap_delete_DerivativeSecurityXML, METH_VARARGS, NULL},
	 { (char *)"DerivativeSecurityXML_swigregister", DerivativeSecurityXML_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StrikeRuleID", _wrap_new_StrikeRuleID, METH_VARARGS, NULL},
	 { (char *)"delete_StrikeRuleID", _wrap_delete_StrikeRuleID, METH_VARARGS, NULL},
	 { (char *)"StrikeRuleID_swigregister", StrikeRuleID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefCompID", _wrap_new_RefCompID, METH_VARARGS, NULL},
	 { (char *)"delete_RefCompID", _wrap_delete_RefCompID, METH_VARARGS, NULL},
	 { (char *)"RefCompID_swigregister", RefCompID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlCurrOfferFxRate", _wrap_new_SettlCurrOfferFxRate, METH_VARARGS, NULL},
	 { (char *)"delete_SettlCurrOfferFxRate", _wrap_delete_SettlCurrOfferFxRate, METH_VARARGS, NULL},
	 { (char *)"SettlCurrOfferFxRate_swigregister", SettlCurrOfferFxRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OfferYield", _wrap_new_OfferYield, METH_VARARGS, NULL},
	 { (char *)"delete_OfferYield", _wrap_delete_OfferYield, METH_VARARGS, NULL},
	 { (char *)"OfferYield_swigregister", OfferYield_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TargetPartyIDSource", _wrap_new_TargetPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_TargetPartyIDSource", _wrap_delete_TargetPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"TargetPartyIDSource_swigregister", TargetPartyIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncryptedNewPasswordLen", _wrap_new_EncryptedNewPasswordLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncryptedNewPasswordLen", _wrap_delete_EncryptedNewPasswordLen, METH_VARARGS, NULL},
	 { (char *)"EncryptedNewPasswordLen_swigregister", EncryptedNewPasswordLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoPositions", _wrap_new_NoPositions, METH_VARARGS, NULL},
	 { (char *)"delete_NoPositions", _wrap_delete_NoPositions, METH_VARARGS, NULL},
	 { (char *)"NoPositions_swigregister", NoPositions_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotalAccruedInterestAmt", _wrap_new_TotalAccruedInterestAmt, METH_VARARGS, NULL},
	 { (char *)"delete_TotalAccruedInterestAmt", _wrap_delete_TotalAccruedInterestAmt, METH_VARARGS, NULL},
	 { (char *)"TotalAccruedInterestAmt_swigregister", TotalAccruedInterestAmt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingOptAttribute", _wrap_new_UnderlyingOptAttribute, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingOptAttribute", _wrap_delete_UnderlyingOptAttribute, METH_VARARGS, NULL},
	 { (char *)"UnderlyingOptAttribute_swigregister", UnderlyingOptAttribute_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeInstrAttribValue", _wrap_new_DerivativeInstrAttribValue, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeInstrAttribValue", _wrap_delete_DerivativeInstrAttribValue, METH_VARARGS, NULL},
	 { (char *)"DerivativeInstrAttribValue_swigregister", DerivativeInstrAttribValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InstrumentPartyIDSource", _wrap_new_InstrumentPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_InstrumentPartyIDSource", _wrap_delete_InstrumentPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"InstrumentPartyIDSource_swigregister", InstrumentPartyIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PegOffsetType", _wrap_new_PegOffsetType, METH_VARARGS, NULL},
	 { (char *)"delete_PegOffsetType", _wrap_delete_PegOffsetType, METH_VARARGS, NULL},
	 { (char *)"PegOffsetType_swigregister", PegOffsetType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MassCancelRejectReason", _wrap_new_MassCancelRejectReason, METH_VARARGS, NULL},
	 { (char *)"delete_MassCancelRejectReason", _wrap_delete_MassCancelRejectReason, METH_VARARGS, NULL},
	 { (char *)"MassCancelRejectReason_swigregister", MassCancelRejectReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResponseTransportType", _wrap_new_ResponseTransportType, METH_VARARGS, NULL},
	 { (char *)"delete_ResponseTransportType", _wrap_delete_ResponseTransportType, METH_VARARGS, NULL},
	 { (char *)"ResponseTransportType_swigregister", ResponseTransportType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSecurityIDSource", _wrap_new_LegSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_LegSecurityIDSource", _wrap_delete_LegSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"LegSecurityIDSource_swigregister", LegSecurityIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BasisFeaturePrice", _wrap_new_BasisFeaturePrice, METH_VARARGS, NULL},
	 { (char *)"delete_BasisFeaturePrice", _wrap_delete_BasisFeaturePrice, METH_VARARGS, NULL},
	 { (char *)"BasisFeaturePrice_swigregister", BasisFeaturePrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CouponPaymentDate", _wrap_new_CouponPaymentDate, METH_VARARGS, NULL},
	 { (char *)"delete_CouponPaymentDate", _wrap_delete_CouponPaymentDate, METH_VARARGS, NULL},
	 { (char *)"CouponPaymentDate_swigregister", CouponPaymentDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradSesStatusRejReason", _wrap_new_TradSesStatusRejReason, METH_VARARGS, NULL},
	 { (char *)"delete_TradSesStatusRejReason", _wrap_delete_TradSesStatusRejReason, METH_VARARGS, NULL},
	 { (char *)"TradSesStatusRejReason_swigregister", TradSesStatusRejReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingDetachmentPoint", _wrap_new_UnderlyingDetachmentPoint, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingDetachmentPoint", _wrap_delete_UnderlyingDetachmentPoint, METH_VARARGS, NULL},
	 { (char *)"UnderlyingDetachmentPoint_swigregister", UnderlyingDetachmentPoint_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaturityRuleID", _wrap_new_MaturityRuleID, METH_VARARGS, NULL},
	 { (char *)"delete_MaturityRuleID", _wrap_delete_MaturityRuleID, METH_VARARGS, NULL},
	 { (char *)"MaturityRuleID_swigregister", MaturityRuleID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingRepoCollateralSecurityType", _wrap_new_UnderlyingRepoCollateralSecurityType, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingRepoCollateralSecurityType", _wrap_delete_UnderlyingRepoCollateralSecurityType, METH_VARARGS, NULL},
	 { (char *)"UnderlyingRepoCollateralSecurityType_swigregister", UnderlyingRepoCollateralSecurityType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoTimeInForceRules", _wrap_new_NoTimeInForceRules, METH_VARARGS, NULL},
	 { (char *)"delete_NoTimeInForceRules", _wrap_delete_NoTimeInForceRules, METH_VARARGS, NULL},
	 { (char *)"NoTimeInForceRules_swigregister", NoTimeInForceRules_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoRootPartySubIDs", _wrap_new_NoRootPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoRootPartySubIDs", _wrap_delete_NoRootPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"NoRootPartySubIDs_swigregister", NoRootPartySubIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DisplayMinIncr", _wrap_new_DisplayMinIncr, METH_VARARGS, NULL},
	 { (char *)"delete_DisplayMinIncr", _wrap_delete_DisplayMinIncr, METH_VARARGS, NULL},
	 { (char *)"DisplayMinIncr_swigregister", DisplayMinIncr_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TrdRegTimestampType", _wrap_new_TrdRegTimestampType, METH_VARARGS, NULL},
	 { (char *)"delete_TrdRegTimestampType", _wrap_delete_TrdRegTimestampType, METH_VARARGS, NULL},
	 { (char *)"TrdRegTimestampType_swigregister", TrdRegTimestampType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegProduct", _wrap_new_LegProduct, METH_VARARGS, NULL},
	 { (char *)"delete_LegProduct", _wrap_delete_LegProduct, METH_VARARGS, NULL},
	 { (char *)"LegProduct_swigregister", LegProduct_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplVerID", _wrap_new_ApplVerID, METH_VARARGS, NULL},
	 { (char *)"delete_ApplVerID", _wrap_delete_ApplVerID, METH_VARARGS, NULL},
	 { (char *)"ApplVerID_swigregister", ApplVerID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HandlInst", _wrap_new_HandlInst, METH_VARARGS, NULL},
	 { (char *)"delete_HandlInst", _wrap_delete_HandlInst, METH_VARARGS, NULL},
	 { (char *)"HandlInst_swigregister", HandlInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ListUpdateAction", _wrap_new_ListUpdateAction, METH_VARARGS, NULL},
	 { (char *)"delete_ListUpdateAction", _wrap_delete_ListUpdateAction, METH_VARARGS, NULL},
	 { (char *)"ListUpdateAction_swigregister", ListUpdateAction_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NestedInstrAttribValue", _wrap_new_NestedInstrAttribValue, METH_VARARGS, NULL},
	 { (char *)"delete_NestedInstrAttribValue", _wrap_delete_NestedInstrAttribValue, METH_VARARGS, NULL},
	 { (char *)"NestedInstrAttribValue_swigregister", NestedInstrAttribValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradingSessionSubID", _wrap_new_TradingSessionSubID, METH_VARARGS, NULL},
	 { (char *)"delete_TradingSessionSubID", _wrap_delete_TradingSessionSubID, METH_VARARGS, NULL},
	 { (char *)"TradingSessionSubID_swigregister", TradingSessionSubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RFQReqID", _wrap_new_RFQReqID, METH_VARARGS, NULL},
	 { (char *)"delete_RFQReqID", _wrap_delete_RFQReqID, METH_VARARGS, NULL},
	 { (char *)"RFQReqID_swigregister", RFQReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegSymbolSfx", _wrap_new_UnderlyingLegSymbolSfx, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegSymbolSfx", _wrap_delete_UnderlyingLegSymbolSfx, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegSymbolSfx_swigregister", UnderlyingLegSymbolSfx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LiquidityNumSecurities", _wrap_new_LiquidityNumSecurities, METH_VARARGS, NULL},
	 { (char *)"delete_LiquidityNumSecurities", _wrap_delete_LiquidityNumSecurities, METH_VARARGS, NULL},
	 { (char *)"LiquidityNumSecurities_swigregister", LiquidityNumSecurities_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoMsgTypes", _wrap_new_NoMsgTypes, METH_VARARGS, NULL},
	 { (char *)"delete_NoMsgTypes", _wrap_delete_NoMsgTypes, METH_VARARGS, NULL},
	 { (char *)"NoMsgTypes_swigregister", NoMsgTypes_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradSesStartTime", _wrap_new_TradSesStartTime, METH_VARARGS, NULL},
	 { (char *)"delete_TradSesStartTime", _wrap_delete_TradSesStartTime, METH_VARARGS, NULL},
	 { (char *)"TradSesStartTime_swigregister", TradSesStartTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDEntryType", _wrap_new_MDEntryType, METH_VARARGS, NULL},
	 { (char *)"delete_MDEntryType", _wrap_delete_MDEntryType, METH_VARARGS, NULL},
	 { (char *)"MDEntryType_swigregister", MDEntryType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AgreementCurrency", _wrap_new_AgreementCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_AgreementCurrency", _wrap_delete_AgreementCurrency, METH_VARARGS, NULL},
	 { (char *)"AgreementCurrency_swigregister", AgreementCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PegMoveType", _wrap_new_PegMoveType, METH_VARARGS, NULL},
	 { (char *)"delete_PegMoveType", _wrap_delete_PegMoveType, METH_VARARGS, NULL},
	 { (char *)"PegMoveType_swigregister", PegMoveType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PegDifference", _wrap_new_PegDifference, METH_VARARGS, NULL},
	 { (char *)"delete_PegDifference", _wrap_delete_PegDifference, METH_VARARGS, NULL},
	 { (char *)"PegDifference_swigregister", PegDifference_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Spread", _wrap_new_Spread, METH_VARARGS, NULL},
	 { (char *)"delete_Spread", _wrap_delete_Spread, METH_VARARGS, NULL},
	 { (char *)"Spread_swigregister", Spread_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedAllocTextLen", _wrap_new_EncodedAllocTextLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedAllocTextLen", _wrap_delete_EncodedAllocTextLen, METH_VARARGS, NULL},
	 { (char *)"EncodedAllocTextLen_swigregister", EncodedAllocTextLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OutsideIndexPct", _wrap_new_OutsideIndexPct, METH_VARARGS, NULL},
	 { (char *)"delete_OutsideIndexPct", _wrap_delete_OutsideIndexPct, METH_VARARGS, NULL},
	 { (char *)"OutsideIndexPct_swigregister", OutsideIndexPct_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivFlexProductEligibilityIndicator", _wrap_new_DerivFlexProductEligibilityIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_DerivFlexProductEligibilityIndicator", _wrap_delete_DerivFlexProductEligibilityIndicator, METH_VARARGS, NULL},
	 { (char *)"DerivFlexProductEligibilityIndicator_swigregister", DerivFlexProductEligibilityIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AvgPxIndicator", _wrap_new_AvgPxIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_AvgPxIndicator", _wrap_delete_AvgPxIndicator, METH_VARARGS, NULL},
	 { (char *)"AvgPxIndicator_swigregister", AvgPxIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoIOIQualifiers", _wrap_new_NoIOIQualifiers, METH_VARARGS, NULL},
	 { (char *)"delete_NoIOIQualifiers", _wrap_delete_NoIOIQualifiers, METH_VARARGS, NULL},
	 { (char *)"NoIOIQualifiers_swigregister", NoIOIQualifiers_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CancellationRights", _wrap_new_CancellationRights, METH_VARARGS, NULL},
	 { (char *)"delete_CancellationRights", _wrap_delete_CancellationRights, METH_VARARGS, NULL},
	 { (char *)"CancellationRights_swigregister", CancellationRights_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ListSeqNo", _wrap_new_ListSeqNo, METH_VARARGS, NULL},
	 { (char *)"delete_ListSeqNo", _wrap_delete_ListSeqNo, METH_VARARGS, NULL},
	 { (char *)"ListSeqNo_swigregister", ListSeqNo_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CardIssNum", _wrap_new_CardIssNum, METH_VARARGS, NULL},
	 { (char *)"delete_CardIssNum", _wrap_delete_CardIssNum, METH_VARARGS, NULL},
	 { (char *)"CardIssNum_swigregister", CardIssNum_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedMktSegmDesc", _wrap_new_EncodedMktSegmDesc, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedMktSegmDesc", _wrap_delete_EncodedMktSegmDesc, METH_VARARGS, NULL},
	 { (char *)"EncodedMktSegmDesc_swigregister", EncodedMktSegmDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeEventType", _wrap_new_DerivativeEventType, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeEventType", _wrap_delete_DerivativeEventType, METH_VARARGS, NULL},
	 { (char *)"DerivativeEventType_swigregister", DerivativeEventType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeMaturityMonthYear", _wrap_new_DerivativeMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeMaturityMonthYear", _wrap_delete_DerivativeMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"DerivativeMaturityMonthYear_swigregister", DerivativeMaturityMonthYear_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideTradeReportID", _wrap_new_SideTradeReportID, METH_VARARGS, NULL},
	 { (char *)"delete_SideTradeReportID", _wrap_delete_SideTradeReportID, METH_VARARGS, NULL},
	 { (char *)"SideTradeReportID_swigregister", SideTradeReportID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoQuoteSets", _wrap_new_NoQuoteSets, METH_VARARGS, NULL},
	 { (char *)"delete_NoQuoteSets", _wrap_delete_NoQuoteSets, METH_VARARGS, NULL},
	 { (char *)"NoQuoteSets_swigregister", NoQuoteSets_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested4PartySubIDType", _wrap_new_Nested4PartySubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_Nested4PartySubIDType", _wrap_delete_Nested4PartySubIDType, METH_VARARGS, NULL},
	 { (char *)"Nested4PartySubIDType_swigregister", Nested4PartySubIDType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FillPx", _wrap_new_FillPx, METH_VARARGS, NULL},
	 { (char *)"delete_FillPx", _wrap_delete_FillPx, METH_VARARGS, NULL},
	 { (char *)"FillPx_swigregister", FillPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StrikeExerciseStyle", _wrap_new_StrikeExerciseStyle, METH_VARARGS, NULL},
	 { (char *)"delete_StrikeExerciseStyle", _wrap_delete_StrikeExerciseStyle, METH_VARARGS, NULL},
	 { (char *)"StrikeExerciseStyle_swigregister", StrikeExerciseStyle_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DeskID", _wrap_new_DeskID, METH_VARARGS, NULL},
	 { (char *)"delete_DeskID", _wrap_delete_DeskID, METH_VARARGS, NULL},
	 { (char *)"DeskID_swigregister", DeskID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CrossPercent", _wrap_new_CrossPercent, METH_VARARGS, NULL},
	 { (char *)"delete_CrossPercent", _wrap_delete_CrossPercent, METH_VARARGS, NULL},
	 { (char *)"CrossPercent_swigregister", CrossPercent_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaturityMonthYear", _wrap_new_MaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"delete_MaturityMonthYear", _wrap_delete_MaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"MaturityMonthYear_swigregister", MaturityMonthYear_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ComplexEventPrice", _wrap_new_ComplexEventPrice, METH_VARARGS, NULL},
	 { (char *)"delete_ComplexEventPrice", _wrap_delete_ComplexEventPrice, METH_VARARGS, NULL},
	 { (char *)"ComplexEventPrice_swigregister", ComplexEventPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoNewsRefIDs", _wrap_new_NoNewsRefIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoNewsRefIDs", _wrap_delete_NoNewsRefIDs, METH_VARARGS, NULL},
	 { (char *)"NoNewsRefIDs_swigregister", NoNewsRefIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingCapValue", _wrap_new_UnderlyingCapValue, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingCapValue", _wrap_delete_UnderlyingCapValue, METH_VARARGS, NULL},
	 { (char *)"UnderlyingCapValue_swigregister", UnderlyingCapValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CPRegType", _wrap_new_CPRegType, METH_VARARGS, NULL},
	 { (char *)"delete_CPRegType", _wrap_delete_CPRegType, METH_VARARGS, NULL},
	 { (char *)"CPRegType_swigregister", CPRegType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashDistribAgentCode", _wrap_new_CashDistribAgentCode, METH_VARARGS, NULL},
	 { (char *)"delete_CashDistribAgentCode", _wrap_delete_CashDistribAgentCode, METH_VARARGS, NULL},
	 { (char *)"CashDistribAgentCode_swigregister", CashDistribAgentCode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExecPriceType", _wrap_new_ExecPriceType, METH_VARARGS, NULL},
	 { (char *)"delete_ExecPriceType", _wrap_delete_ExecPriceType, METH_VARARGS, NULL},
	 { (char *)"ExecPriceType_swigregister", ExecPriceType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegAllocID", _wrap_new_LegAllocID, METH_VARARGS, NULL},
	 { (char *)"delete_LegAllocID", _wrap_delete_LegAllocID, METH_VARARGS, NULL},
	 { (char *)"LegAllocID_swigregister", LegAllocID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDEntryTime", _wrap_new_MDEntryTime, METH_VARARGS, NULL},
	 { (char *)"delete_MDEntryTime", _wrap_delete_MDEntryTime, METH_VARARGS, NULL},
	 { (char *)"MDEntryTime_swigregister", MDEntryTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotalNumSecurities", _wrap_new_TotalNumSecurities, METH_VARARGS, NULL},
	 { (char *)"delete_TotalNumSecurities", _wrap_delete_TotalNumSecurities, METH_VARARGS, NULL},
	 { (char *)"TotalNumSecurities_swigregister", TotalNumSecurities_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocSettlInstType", _wrap_new_AllocSettlInstType, METH_VARARGS, NULL},
	 { (char *)"delete_AllocSettlInstType", _wrap_delete_AllocSettlInstType, METH_VARARGS, NULL},
	 { (char *)"AllocSettlInstType_swigregister", AllocSettlInstType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TargetPartyID", _wrap_new_TargetPartyID, METH_VARARGS, NULL},
	 { (char *)"delete_TargetPartyID", _wrap_delete_TargetPartyID, METH_VARARGS, NULL},
	 { (char *)"TargetPartyID_swigregister", TargetPartyID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeStrikeCurrency", _wrap_new_DerivativeStrikeCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeStrikeCurrency", _wrap_delete_DerivativeStrikeCurrency, METH_VARARGS, NULL},
	 { (char *)"DerivativeStrikeCurrency_swigregister", DerivativeStrikeCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StatsType", _wrap_new_StatsType, METH_VARARGS, NULL},
	 { (char *)"delete_StatsType", _wrap_delete_StatsType, METH_VARARGS, NULL},
	 { (char *)"StatsType_swigregister", StatsType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplExtID", _wrap_new_ApplExtID, METH_VARARGS, NULL},
	 { (char *)"delete_ApplExtID", _wrap_delete_ApplExtID, METH_VARARGS, NULL},
	 { (char *)"ApplExtID_swigregister", ApplExtID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlementCycleNo", _wrap_new_SettlementCycleNo, METH_VARARGS, NULL},
	 { (char *)"delete_SettlementCycleNo", _wrap_delete_SettlementCycleNo, METH_VARARGS, NULL},
	 { (char *)"SettlementCycleNo_swigregister", SettlementCycleNo_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingStrikeCurrency", _wrap_new_UnderlyingStrikeCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingStrikeCurrency", _wrap_delete_UnderlyingStrikeCurrency, METH_VARARGS, NULL},
	 { (char *)"UnderlyingStrikeCurrency_swigregister", UnderlyingStrikeCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradSesMode", _wrap_new_TradSesMode, METH_VARARGS, NULL},
	 { (char *)"delete_TradSesMode", _wrap_delete_TradSesMode, METH_VARARGS, NULL},
	 { (char *)"TradSesMode_swigregister", TradSesMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlInstSource", _wrap_new_SettlInstSource, METH_VARARGS, NULL},
	 { (char *)"delete_SettlInstSource", _wrap_delete_SettlInstSource, METH_VARARGS, NULL},
	 { (char *)"SettlInstSource_swigregister", SettlInstSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegSecurityDesc", _wrap_new_UnderlyingLegSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegSecurityDesc", _wrap_delete_UnderlyingLegSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegSecurityDesc_swigregister", UnderlyingLegSecurityDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoDerivativeInstrumentParties", _wrap_new_NoDerivativeInstrumentParties, METH_VARARGS, NULL},
	 { (char *)"delete_NoDerivativeInstrumentParties", _wrap_delete_NoDerivativeInstrumentParties, METH_VARARGS, NULL},
	 { (char *)"NoDerivativeInstrumentParties_swigregister", NoDerivativeInstrumentParties_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeEventTime", _wrap_new_DerivativeEventTime, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeEventTime", _wrap_delete_DerivativeEventTime, METH_VARARGS, NULL},
	 { (char *)"DerivativeEventTime_swigregister", DerivativeEventTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TickIncrement", _wrap_new_TickIncrement, METH_VARARGS, NULL},
	 { (char *)"delete_TickIncrement", _wrap_delete_TickIncrement, METH_VARARGS, NULL},
	 { (char *)"TickIncrement_swigregister", TickIncrement_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UndlyInstrumentPartyID", _wrap_new_UndlyInstrumentPartyID, METH_VARARGS, NULL},
	 { (char *)"delete_UndlyInstrumentPartyID", _wrap_delete_UndlyInstrumentPartyID, METH_VARARGS, NULL},
	 { (char *)"UndlyInstrumentPartyID_swigregister", UndlyInstrumentPartyID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoUndlyInstrumentParties", _wrap_new_NoUndlyInstrumentParties, METH_VARARGS, NULL},
	 { (char *)"delete_NoUndlyInstrumentParties", _wrap_delete_NoUndlyInstrumentParties, METH_VARARGS, NULL},
	 { (char *)"NoUndlyInstrumentParties_swigregister", NoUndlyInstrumentParties_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExpType", _wrap_new_ExpType, METH_VARARGS, NULL},
	 { (char *)"delete_ExpType", _wrap_delete_ExpType, METH_VARARGS, NULL},
	 { (char *)"ExpType_swigregister", ExpType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryClOrdID", _wrap_new_SecondaryClOrdID, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryClOrdID", _wrap_delete_SecondaryClOrdID, METH_VARARGS, NULL},
	 { (char *)"SecondaryClOrdID_swigregister", SecondaryClOrdID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlInstTransType", _wrap_new_SettlInstTransType, METH_VARARGS, NULL},
	 { (char *)"delete_SettlInstTransType", _wrap_delete_SettlInstTransType, METH_VARARGS, NULL},
	 { (char *)"SettlInstTransType_swigregister", SettlInstTransType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideComplianceID", _wrap_new_SideComplianceID, METH_VARARGS, NULL},
	 { (char *)"delete_SideComplianceID", _wrap_delete_SideComplianceID, METH_VARARGS, NULL},
	 { (char *)"SideComplianceID_swigregister", SideComplianceID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeRequestResult", _wrap_new_TradeRequestResult, METH_VARARGS, NULL},
	 { (char *)"delete_TradeRequestResult", _wrap_delete_TradeRequestResult, METH_VARARGS, NULL},
	 { (char *)"TradeRequestResult_swigregister", TradeRequestResult_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrigPosReqRefID", _wrap_new_OrigPosReqRefID, METH_VARARGS, NULL},
	 { (char *)"delete_OrigPosReqRefID", _wrap_delete_OrigPosReqRefID, METH_VARARGS, NULL},
	 { (char *)"OrigPosReqRefID_swigregister", OrigPosReqRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrigCrossID", _wrap_new_OrigCrossID, METH_VARARGS, NULL},
	 { (char *)"delete_OrigCrossID", _wrap_delete_OrigCrossID, METH_VARARGS, NULL},
	 { (char *)"OrigCrossID_swigregister", OrigCrossID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeInputSource", _wrap_new_TradeInputSource, METH_VARARGS, NULL},
	 { (char *)"delete_TradeInputSource", _wrap_delete_TradeInputSource, METH_VARARGS, NULL},
	 { (char *)"TradeInputSource_swigregister", TradeInputSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrderQty2", _wrap_new_OrderQty2, METH_VARARGS, NULL},
	 { (char *)"delete_OrderQty2", _wrap_delete_OrderQty2, METH_VARARGS, NULL},
	 { (char *)"OrderQty2_swigregister", OrderQty2_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TestMessageIndicator", _wrap_new_TestMessageIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_TestMessageIndicator", _wrap_delete_TestMessageIndicator, METH_VARARGS, NULL},
	 { (char *)"TestMessageIndicator_swigregister", TestMessageIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeEventDate", _wrap_new_DerivativeEventDate, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeEventDate", _wrap_delete_DerivativeEventDate, METH_VARARGS, NULL},
	 { (char *)"DerivativeEventDate_swigregister", DerivativeEventDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideGrossTradeAmt", _wrap_new_SideGrossTradeAmt, METH_VARARGS, NULL},
	 { (char *)"delete_SideGrossTradeAmt", _wrap_delete_SideGrossTradeAmt, METH_VARARGS, NULL},
	 { (char *)"SideGrossTradeAmt_swigregister", SideGrossTradeAmt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PeggedPrice", _wrap_new_PeggedPrice, METH_VARARGS, NULL},
	 { (char *)"delete_PeggedPrice", _wrap_delete_PeggedPrice, METH_VARARGS, NULL},
	 { (char *)"PeggedPrice_swigregister", PeggedPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExpirationCycle", _wrap_new_ExpirationCycle, METH_VARARGS, NULL},
	 { (char *)"delete_ExpirationCycle", _wrap_delete_ExpirationCycle, METH_VARARGS, NULL},
	 { (char *)"ExpirationCycle_swigregister", ExpirationCycle_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocCancReplaceReason", _wrap_new_AllocCancReplaceReason, METH_VARARGS, NULL},
	 { (char *)"delete_AllocCancReplaceReason", _wrap_delete_AllocCancReplaceReason, METH_VARARGS, NULL},
	 { (char *)"AllocCancReplaceReason_swigregister", AllocCancReplaceReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CxlRejReason", _wrap_new_CxlRejReason, METH_VARARGS, NULL},
	 { (char *)"delete_CxlRejReason", _wrap_delete_CxlRejReason, METH_VARARGS, NULL},
	 { (char *)"CxlRejReason_swigregister", CxlRejReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BeginString", _wrap_new_BeginString, METH_VARARGS, NULL},
	 { (char *)"delete_BeginString", _wrap_delete_BeginString, METH_VARARGS, NULL},
	 { (char *)"BeginString_swigregister", BeginString_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DeliverToSubID", _wrap_new_DeliverToSubID, METH_VARARGS, NULL},
	 { (char *)"delete_DeliverToSubID", _wrap_delete_DeliverToSubID, METH_VARARGS, NULL},
	 { (char *)"DeliverToSubID_swigregister", DeliverToSubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegPriceUnitOfMeasureQty", _wrap_new_LegPriceUnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"delete_LegPriceUnitOfMeasureQty", _wrap_delete_LegPriceUnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"LegPriceUnitOfMeasureQty_swigregister", LegPriceUnitOfMeasureQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoCollInquiryQualifier", _wrap_new_NoCollInquiryQualifier, METH_VARARGS, NULL},
	 { (char *)"delete_NoCollInquiryQualifier", _wrap_delete_NoCollInquiryQualifier, METH_VARARGS, NULL},
	 { (char *)"NoCollInquiryQualifier_swigregister", NoCollInquiryQualifier_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OfferPx", _wrap_new_OfferPx, METH_VARARGS, NULL},
	 { (char *)"delete_OfferPx", _wrap_delete_OfferPx, METH_VARARGS, NULL},
	 { (char *)"OfferPx_swigregister", OfferPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotalVolumeTradedDate", _wrap_new_TotalVolumeTradedDate, METH_VARARGS, NULL},
	 { (char *)"delete_TotalVolumeTradedDate", _wrap_delete_TotalVolumeTradedDate, METH_VARARGS, NULL},
	 { (char *)"TotalVolumeTradedDate_swigregister", TotalVolumeTradedDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoContAmts", _wrap_new_NoContAmts, METH_VARARGS, NULL},
	 { (char *)"delete_NoContAmts", _wrap_delete_NoContAmts, METH_VARARGS, NULL},
	 { (char *)"NoContAmts_swigregister", NoContAmts_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MinOfferSize", _wrap_new_MinOfferSize, METH_VARARGS, NULL},
	 { (char *)"delete_MinOfferSize", _wrap_delete_MinOfferSize, METH_VARARGS, NULL},
	 { (char *)"MinOfferSize_swigregister", MinOfferSize_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AvgParPx", _wrap_new_AvgParPx, METH_VARARGS, NULL},
	 { (char *)"delete_AvgParPx", _wrap_delete_AvgParPx, METH_VARARGS, NULL},
	 { (char *)"AvgParPx_swigregister", AvgParPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegFactor", _wrap_new_LegFactor, METH_VARARGS, NULL},
	 { (char *)"delete_LegFactor", _wrap_delete_LegFactor, METH_VARARGS, NULL},
	 { (char *)"LegFactor_swigregister", LegFactor_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RespondentType", _wrap_new_RespondentType, METH_VARARGS, NULL},
	 { (char *)"delete_RespondentType", _wrap_delete_RespondentType, METH_VARARGS, NULL},
	 { (char *)"RespondentType_swigregister", RespondentType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DisplayLowQty", _wrap_new_DisplayLowQty, METH_VARARGS, NULL},
	 { (char *)"delete_DisplayLowQty", _wrap_delete_DisplayLowQty, METH_VARARGS, NULL},
	 { (char *)"DisplayLowQty_swigregister", DisplayLowQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DKReason", _wrap_new_DKReason, METH_VARARGS, NULL},
	 { (char *)"delete_DKReason", _wrap_delete_DKReason, METH_VARARGS, NULL},
	 { (char *)"DKReason_swigregister", DKReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BenchmarkPrice", _wrap_new_BenchmarkPrice, METH_VARARGS, NULL},
	 { (char *)"delete_BenchmarkPrice", _wrap_delete_BenchmarkPrice, METH_VARARGS, NULL},
	 { (char *)"BenchmarkPrice_swigregister", BenchmarkPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ListID", _wrap_new_ListID, METH_VARARGS, NULL},
	 { (char *)"delete_ListID", _wrap_delete_ListID, METH_VARARGS, NULL},
	 { (char *)"ListID_swigregister", ListID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSecurityAltID", _wrap_new_LegSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"delete_LegSecurityAltID", _wrap_delete_LegSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"LegSecurityAltID_swigregister", LegSecurityAltID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PositionEffect", _wrap_new_PositionEffect, METH_VARARGS, NULL},
	 { (char *)"delete_PositionEffect", _wrap_delete_PositionEffect, METH_VARARGS, NULL},
	 { (char *)"PositionEffect_swigregister", PositionEffect_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerAction", _wrap_new_TriggerAction, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerAction", _wrap_delete_TriggerAction, METH_VARARGS, NULL},
	 { (char *)"TriggerAction_swigregister", TriggerAction_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefOrderID", _wrap_new_RefOrderID, METH_VARARGS, NULL},
	 { (char *)"delete_RefOrderID", _wrap_delete_RefOrderID, METH_VARARGS, NULL},
	 { (char *)"RefOrderID_swigregister", RefOrderID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ClearingInstruction", _wrap_new_ClearingInstruction, METH_VARARGS, NULL},
	 { (char *)"delete_ClearingInstruction", _wrap_delete_ClearingInstruction, METH_VARARGS, NULL},
	 { (char *)"ClearingInstruction_swigregister", ClearingInstruction_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlInstCode", _wrap_new_SettlInstCode, METH_VARARGS, NULL},
	 { (char *)"delete_SettlInstCode", _wrap_delete_SettlInstCode, METH_VARARGS, NULL},
	 { (char *)"SettlInstCode_swigregister", SettlInstCode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NumDaysInterest", _wrap_new_NumDaysInterest, METH_VARARGS, NULL},
	 { (char *)"delete_NumDaysInterest", _wrap_delete_NumDaysInterest, METH_VARARGS, NULL},
	 { (char *)"NumDaysInterest_swigregister", NumDaysInterest_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OpenCloseSettlFlag", _wrap_new_OpenCloseSettlFlag, METH_VARARGS, NULL},
	 { (char *)"delete_OpenCloseSettlFlag", _wrap_delete_OpenCloseSettlFlag, METH_VARARGS, NULL},
	 { (char *)"OpenCloseSettlFlag_swigregister", OpenCloseSettlFlag_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoComplexEventDates", _wrap_new_NoComplexEventDates, METH_VARARGS, NULL},
	 { (char *)"delete_NoComplexEventDates", _wrap_delete_NoComplexEventDates, METH_VARARGS, NULL},
	 { (char *)"NoComplexEventDates_swigregister", NoComplexEventDates_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeEncodedIssuerLen", _wrap_new_DerivativeEncodedIssuerLen, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeEncodedIssuerLen", _wrap_delete_DerivativeEncodedIssuerLen, METH_VARARGS, NULL},
	 { (char *)"DerivativeEncodedIssuerLen_swigregister", DerivativeEncodedIssuerLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StrikeMultiplier", _wrap_new_StrikeMultiplier, METH_VARARGS, NULL},
	 { (char *)"delete_StrikeMultiplier", _wrap_delete_StrikeMultiplier, METH_VARARGS, NULL},
	 { (char *)"StrikeMultiplier_swigregister", StrikeMultiplier_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DiscretionMoveType", _wrap_new_DiscretionMoveType, METH_VARARGS, NULL},
	 { (char *)"delete_DiscretionMoveType", _wrap_delete_DiscretionMoveType, METH_VARARGS, NULL},
	 { (char *)"DiscretionMoveType_swigregister", DiscretionMoveType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ListNoOrds", _wrap_new_ListNoOrds, METH_VARARGS, NULL},
	 { (char *)"delete_ListNoOrds", _wrap_delete_ListNoOrds, METH_VARARGS, NULL},
	 { (char *)"ListNoOrds_swigregister", ListNoOrds_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PegSymbol", _wrap_new_PegSymbol, METH_VARARGS, NULL},
	 { (char *)"delete_PegSymbol", _wrap_delete_PegSymbol, METH_VARARGS, NULL},
	 { (char *)"PegSymbol_swigregister", PegSymbol_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DayAvgPx", _wrap_new_DayAvgPx, METH_VARARGS, NULL},
	 { (char *)"delete_DayAvgPx", _wrap_delete_DayAvgPx, METH_VARARGS, NULL},
	 { (char *)"DayAvgPx_swigregister", DayAvgPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Headline", _wrap_new_Headline, METH_VARARGS, NULL},
	 { (char *)"delete_Headline", _wrap_delete_Headline, METH_VARARGS, NULL},
	 { (char *)"Headline_swigregister", Headline_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NestedPartySubID", _wrap_new_NestedPartySubID, METH_VARARGS, NULL},
	 { (char *)"delete_NestedPartySubID", _wrap_delete_NestedPartySubID, METH_VARARGS, NULL},
	 { (char *)"NestedPartySubID_swigregister", NestedPartySubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CardIssNo", _wrap_new_CardIssNo, METH_VARARGS, NULL},
	 { (char *)"delete_CardIssNo", _wrap_delete_CardIssNo, METH_VARARGS, NULL},
	 { (char *)"CardIssNo_swigregister", CardIssNo_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OptAttribute", _wrap_new_OptAttribute, METH_VARARGS, NULL},
	 { (char *)"delete_OptAttribute", _wrap_delete_OptAttribute, METH_VARARGS, NULL},
	 { (char *)"OptAttribute_swigregister", OptAttribute_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastForwardPoints2", _wrap_new_LastForwardPoints2, METH_VARARGS, NULL},
	 { (char *)"delete_LastForwardPoints2", _wrap_delete_LastForwardPoints2, METH_VARARGS, NULL},
	 { (char *)"LastForwardPoints2_swigregister", LastForwardPoints2_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDUpdateType", _wrap_new_MDUpdateType, METH_VARARGS, NULL},
	 { (char *)"delete_MDUpdateType", _wrap_delete_MDUpdateType, METH_VARARGS, NULL},
	 { (char *)"MDUpdateType_swigregister", MDUpdateType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TickDirection", _wrap_new_TickDirection, METH_VARARGS, NULL},
	 { (char *)"delete_TickDirection", _wrap_delete_TickDirection, METH_VARARGS, NULL},
	 { (char *)"TickDirection_swigregister", TickDirection_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegRedemptionDate", _wrap_new_LegRedemptionDate, METH_VARARGS, NULL},
	 { (char *)"delete_LegRedemptionDate", _wrap_delete_LegRedemptionDate, METH_VARARGS, NULL},
	 { (char *)"LegRedemptionDate_swigregister", LegRedemptionDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StrikePrice", _wrap_new_StrikePrice, METH_VARARGS, NULL},
	 { (char *)"delete_StrikePrice", _wrap_delete_StrikePrice, METH_VARARGS, NULL},
	 { (char *)"StrikePrice_swigregister", StrikePrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedIssuer", _wrap_new_EncodedIssuer, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedIssuer", _wrap_delete_EncodedIssuer, METH_VARARGS, NULL},
	 { (char *)"EncodedIssuer_swigregister", EncodedIssuer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_YieldType", _wrap_new_YieldType, METH_VARARGS, NULL},
	 { (char *)"delete_YieldType", _wrap_delete_YieldType, METH_VARARGS, NULL},
	 { (char *)"YieldType_swigregister", YieldType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradingReferencePrice", _wrap_new_TradingReferencePrice, METH_VARARGS, NULL},
	 { (char *)"delete_TradingReferencePrice", _wrap_delete_TradingReferencePrice, METH_VARARGS, NULL},
	 { (char *)"TradingReferencePrice_swigregister", TradingReferencePrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDEntrySpotRate", _wrap_new_MDEntrySpotRate, METH_VARARGS, NULL},
	 { (char *)"delete_MDEntrySpotRate", _wrap_delete_MDEntrySpotRate, METH_VARARGS, NULL},
	 { (char *)"MDEntrySpotRate_swigregister", MDEntrySpotRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ParticipationRate", _wrap_new_ParticipationRate, METH_VARARGS, NULL},
	 { (char *)"delete_ParticipationRate", _wrap_delete_ParticipationRate, METH_VARARGS, NULL},
	 { (char *)"ParticipationRate_swigregister", ParticipationRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PegScope", _wrap_new_PegScope, METH_VARARGS, NULL},
	 { (char *)"delete_PegScope", _wrap_delete_PegScope, METH_VARARGS, NULL},
	 { (char *)"PegScope_swigregister", PegScope_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InterestAtMaturity", _wrap_new_InterestAtMaturity, METH_VARARGS, NULL},
	 { (char *)"delete_InterestAtMaturity", _wrap_delete_InterestAtMaturity, METH_VARARGS, NULL},
	 { (char *)"InterestAtMaturity_swigregister", InterestAtMaturity_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegIndividualAllocID", _wrap_new_LegIndividualAllocID, METH_VARARGS, NULL},
	 { (char *)"delete_LegIndividualAllocID", _wrap_delete_LegIndividualAllocID, METH_VARARGS, NULL},
	 { (char *)"LegIndividualAllocID_swigregister", LegIndividualAllocID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllowableOneSidednessValue", _wrap_new_AllowableOneSidednessValue, METH_VARARGS, NULL},
	 { (char *)"delete_AllowableOneSidednessValue", _wrap_delete_AllowableOneSidednessValue, METH_VARARGS, NULL},
	 { (char *)"AllowableOneSidednessValue_swigregister", AllowableOneSidednessValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashSettlAgentName", _wrap_new_CashSettlAgentName, METH_VARARGS, NULL},
	 { (char *)"delete_CashSettlAgentName", _wrap_delete_CashSettlAgentName, METH_VARARGS, NULL},
	 { (char *)"CashSettlAgentName_swigregister", CashSettlAgentName_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ContraTradeQty", _wrap_new_ContraTradeQty, METH_VARARGS, NULL},
	 { (char *)"delete_ContraTradeQty", _wrap_delete_ContraTradeQty, METH_VARARGS, NULL},
	 { (char *)"ContraTradeQty_swigregister", ContraTradeQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegMaturityTime", _wrap_new_LegMaturityTime, METH_VARARGS, NULL},
	 { (char *)"delete_LegMaturityTime", _wrap_delete_LegMaturityTime, METH_VARARGS, NULL},
	 { (char *)"LegMaturityTime_swigregister", LegMaturityTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlDeliveryType", _wrap_new_SettlDeliveryType, METH_VARARGS, NULL},
	 { (char *)"delete_SettlDeliveryType", _wrap_delete_SettlDeliveryType, METH_VARARGS, NULL},
	 { (char *)"SettlDeliveryType_swigregister", SettlDeliveryType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryPriceLimitType", _wrap_new_SecondaryPriceLimitType, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryPriceLimitType", _wrap_delete_SecondaryPriceLimitType, METH_VARARGS, NULL},
	 { (char *)"SecondaryPriceLimitType_swigregister", SecondaryPriceLimitType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MidPx", _wrap_new_MidPx, METH_VARARGS, NULL},
	 { (char *)"delete_MidPx", _wrap_delete_MidPx, METH_VARARGS, NULL},
	 { (char *)"MidPx_swigregister", MidPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AvgPx", _wrap_new_AvgPx, METH_VARARGS, NULL},
	 { (char *)"delete_AvgPx", _wrap_delete_AvgPx, METH_VARARGS, NULL},
	 { (char *)"AvgPx_swigregister", AvgPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DiscretionLimitType", _wrap_new_DiscretionLimitType, METH_VARARGS, NULL},
	 { (char *)"delete_DiscretionLimitType", _wrap_delete_DiscretionLimitType, METH_VARARGS, NULL},
	 { (char *)"DiscretionLimitType_swigregister", DiscretionLimitType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StrikeTime", _wrap_new_StrikeTime, METH_VARARGS, NULL},
	 { (char *)"delete_StrikeTime", _wrap_delete_StrikeTime, METH_VARARGS, NULL},
	 { (char *)"StrikeTime_swigregister", StrikeTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlSessSubID", _wrap_new_SettlSessSubID, METH_VARARGS, NULL},
	 { (char *)"delete_SettlSessSubID", _wrap_delete_SettlSessSubID, METH_VARARGS, NULL},
	 { (char *)"SettlSessSubID_swigregister", SettlSessSubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MailingDtls", _wrap_new_MailingDtls, METH_VARARGS, NULL},
	 { (char *)"delete_MailingDtls", _wrap_delete_MailingDtls, METH_VARARGS, NULL},
	 { (char *)"MailingDtls_swigregister", MailingDtls_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BidID", _wrap_new_BidID, METH_VARARGS, NULL},
	 { (char *)"delete_BidID", _wrap_delete_BidID, METH_VARARGS, NULL},
	 { (char *)"BidID_swigregister", BidID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExerciseMethod", _wrap_new_ExerciseMethod, METH_VARARGS, NULL},
	 { (char *)"delete_ExerciseMethod", _wrap_delete_ExerciseMethod, METH_VARARGS, NULL},
	 { (char *)"ExerciseMethod_swigregister", ExerciseMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CommCurrency", _wrap_new_CommCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_CommCurrency", _wrap_delete_CommCurrency, METH_VARARGS, NULL},
	 { (char *)"CommCurrency_swigregister", CommCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoSettlOblig", _wrap_new_NoSettlOblig, METH_VARARGS, NULL},
	 { (char *)"delete_NoSettlOblig", _wrap_delete_NoSettlOblig, METH_VARARGS, NULL},
	 { (char *)"NoSettlOblig_swigregister", NoSettlOblig_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaxPriceVariation", _wrap_new_MaxPriceVariation, METH_VARARGS, NULL},
	 { (char *)"delete_MaxPriceVariation", _wrap_delete_MaxPriceVariation, METH_VARARGS, NULL},
	 { (char *)"MaxPriceVariation_swigregister", MaxPriceVariation_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_WorkingIndicator", _wrap_new_WorkingIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_WorkingIndicator", _wrap_delete_WorkingIndicator, METH_VARARGS, NULL},
	 { (char *)"WorkingIndicator_swigregister", WorkingIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashSettlAgentAcctName", _wrap_new_CashSettlAgentAcctName, METH_VARARGS, NULL},
	 { (char *)"delete_CashSettlAgentAcctName", _wrap_delete_CashSettlAgentAcctName, METH_VARARGS, NULL},
	 { (char *)"CashSettlAgentAcctName_swigregister", CashSettlAgentAcctName_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SellVolume", _wrap_new_SellVolume, METH_VARARGS, NULL},
	 { (char *)"delete_SellVolume", _wrap_delete_SellVolume, METH_VARARGS, NULL},
	 { (char *)"SellVolume_swigregister", SellVolume_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideMultiLegReportingType", _wrap_new_SideMultiLegReportingType, METH_VARARGS, NULL},
	 { (char *)"delete_SideMultiLegReportingType", _wrap_delete_SideMultiLegReportingType, METH_VARARGS, NULL},
	 { (char *)"SideMultiLegReportingType_swigregister", SideMultiLegReportingType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeEventText", _wrap_new_DerivativeEventText, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeEventText", _wrap_delete_DerivativeEventText, METH_VARARGS, NULL},
	 { (char *)"DerivativeEventText_swigregister", DerivativeEventText_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PegSecurityDesc", _wrap_new_PegSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_PegSecurityDesc", _wrap_delete_PegSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"PegSecurityDesc_swigregister", PegSecurityDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocCustomerCapacity", _wrap_new_AllocCustomerCapacity, METH_VARARGS, NULL},
	 { (char *)"delete_AllocCustomerCapacity", _wrap_delete_AllocCustomerCapacity, METH_VARARGS, NULL},
	 { (char *)"AllocCustomerCapacity_swigregister", AllocCustomerCapacity_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ConfirmRejReason", _wrap_new_ConfirmRejReason, METH_VARARGS, NULL},
	 { (char *)"delete_ConfirmRejReason", _wrap_delete_ConfirmRejReason, METH_VARARGS, NULL},
	 { (char *)"ConfirmRejReason_swigregister", ConfirmRejReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BidRequestTransType", _wrap_new_BidRequestTransType, METH_VARARGS, NULL},
	 { (char *)"delete_BidRequestTransType", _wrap_delete_BidRequestTransType, METH_VARARGS, NULL},
	 { (char *)"BidRequestTransType_swigregister", BidRequestTransType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashDistribAgentAcctNumber", _wrap_new_CashDistribAgentAcctNumber, METH_VARARGS, NULL},
	 { (char *)"delete_CashDistribAgentAcctNumber", _wrap_delete_CashDistribAgentAcctNumber, METH_VARARGS, NULL},
	 { (char *)"CashDistribAgentAcctNumber_swigregister", CashDistribAgentAcctNumber_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegExecInst", _wrap_new_LegExecInst, METH_VARARGS, NULL},
	 { (char *)"delete_LegExecInst", _wrap_delete_LegExecInst, METH_VARARGS, NULL},
	 { (char *)"LegExecInst_swigregister", LegExecInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CapPrice", _wrap_new_CapPrice, METH_VARARGS, NULL},
	 { (char *)"delete_CapPrice", _wrap_delete_CapPrice, METH_VARARGS, NULL},
	 { (char *)"CapPrice_swigregister", CapPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegRepurchaseTerm", _wrap_new_LegRepurchaseTerm, METH_VARARGS, NULL},
	 { (char *)"delete_LegRepurchaseTerm", _wrap_delete_LegRepurchaseTerm, METH_VARARGS, NULL},
	 { (char *)"LegRepurchaseTerm_swigregister", LegRepurchaseTerm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RegistAcctType", _wrap_new_RegistAcctType, METH_VARARGS, NULL},
	 { (char *)"delete_RegistAcctType", _wrap_delete_RegistAcctType, METH_VARARGS, NULL},
	 { (char *)"RegistAcctType_swigregister", RegistAcctType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MassActionRejectReason", _wrap_new_MassActionRejectReason, METH_VARARGS, NULL},
	 { (char *)"delete_MassActionRejectReason", _wrap_delete_MassActionRejectReason, METH_VARARGS, NULL},
	 { (char *)"MassActionRejectReason_swigregister", MassActionRejectReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativePutOrCall", _wrap_new_DerivativePutOrCall, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativePutOrCall", _wrap_delete_DerivativePutOrCall, METH_VARARGS, NULL},
	 { (char *)"DerivativePutOrCall_swigregister", DerivativePutOrCall_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StartMaturityMonthYear", _wrap_new_StartMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"delete_StartMaturityMonthYear", _wrap_delete_StartMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"StartMaturityMonthYear_swigregister", StartMaturityMonthYear_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollApplType", _wrap_new_CollApplType, METH_VARARGS, NULL},
	 { (char *)"delete_CollApplType", _wrap_delete_CollApplType, METH_VARARGS, NULL},
	 { (char *)"CollApplType_swigregister", CollApplType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoUnderlyingAmounts", _wrap_new_NoUnderlyingAmounts, METH_VARARGS, NULL},
	 { (char *)"delete_NoUnderlyingAmounts", _wrap_delete_NoUnderlyingAmounts, METH_VARARGS, NULL},
	 { (char *)"NoUnderlyingAmounts_swigregister", NoUnderlyingAmounts_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ConfirmType", _wrap_new_ConfirmType, METH_VARARGS, NULL},
	 { (char *)"delete_ConfirmType", _wrap_delete_ConfirmType, METH_VARARGS, NULL},
	 { (char *)"ConfirmType_swigregister", ConfirmType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegMaturityMonthYear", _wrap_new_LegMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"delete_LegMaturityMonthYear", _wrap_delete_LegMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"LegMaturityMonthYear_swigregister", LegMaturityMonthYear_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RelatdSym", _wrap_new_RelatdSym, METH_VARARGS, NULL},
	 { (char *)"delete_RelatdSym", _wrap_delete_RelatdSym, METH_VARARGS, NULL},
	 { (char *)"RelatdSym_swigregister", RelatdSym_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegSecuritySubType", _wrap_new_UnderlyingLegSecuritySubType, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegSecuritySubType", _wrap_delete_UnderlyingLegSecuritySubType, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegSecuritySubType_swigregister", UnderlyingLegSecuritySubType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoUnderlyingSecurityAltID", _wrap_new_NoUnderlyingSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"delete_NoUnderlyingSecurityAltID", _wrap_delete_NoUnderlyingSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"NoUnderlyingSecurityAltID_swigregister", NoUnderlyingSecurityAltID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDQuoteType", _wrap_new_MDQuoteType, METH_VARARGS, NULL},
	 { (char *)"delete_MDQuoteType", _wrap_delete_MDQuoteType, METH_VARARGS, NULL},
	 { (char *)"MDQuoteType_swigregister", MDQuoteType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QtyType", _wrap_new_QtyType, METH_VARARGS, NULL},
	 { (char *)"delete_QtyType", _wrap_delete_QtyType, METH_VARARGS, NULL},
	 { (char *)"QtyType_swigregister", QtyType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteRespType", _wrap_new_QuoteRespType, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteRespType", _wrap_delete_QuoteRespType, METH_VARARGS, NULL},
	 { (char *)"QuoteRespType_swigregister", QuoteRespType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IOINaturalFlag", _wrap_new_IOINaturalFlag, METH_VARARGS, NULL},
	 { (char *)"delete_IOINaturalFlag", _wrap_delete_IOINaturalFlag, METH_VARARGS, NULL},
	 { (char *)"IOINaturalFlag_swigregister", IOINaturalFlag_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BenchmarkCurvePoint", _wrap_new_BenchmarkCurvePoint, METH_VARARGS, NULL},
	 { (char *)"delete_BenchmarkCurvePoint", _wrap_delete_BenchmarkCurvePoint, METH_VARARGS, NULL},
	 { (char *)"BenchmarkCurvePoint_swigregister", BenchmarkCurvePoint_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradSesUpdateAction", _wrap_new_TradSesUpdateAction, METH_VARARGS, NULL},
	 { (char *)"delete_TradSesUpdateAction", _wrap_delete_TradSesUpdateAction, METH_VARARGS, NULL},
	 { (char *)"TradSesUpdateAction_swigregister", TradSesUpdateAction_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingCashAmount", _wrap_new_UnderlyingCashAmount, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingCashAmount", _wrap_delete_UnderlyingCashAmount, METH_VARARGS, NULL},
	 { (char *)"UnderlyingCashAmount_swigregister", UnderlyingCashAmount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollAsgnID", _wrap_new_CollAsgnID, METH_VARARGS, NULL},
	 { (char *)"delete_CollAsgnID", _wrap_delete_CollAsgnID, METH_VARARGS, NULL},
	 { (char *)"CollAsgnID_swigregister", CollAsgnID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExchangeRule", _wrap_new_ExchangeRule, METH_VARARGS, NULL},
	 { (char *)"delete_ExchangeRule", _wrap_delete_ExchangeRule, METH_VARARGS, NULL},
	 { (char *)"ExchangeRule_swigregister", ExchangeRule_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedHeadline", _wrap_new_EncodedHeadline, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedHeadline", _wrap_delete_EncodedHeadline, METH_VARARGS, NULL},
	 { (char *)"EncodedHeadline_swigregister", EncodedHeadline_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RegistID", _wrap_new_RegistID, METH_VARARGS, NULL},
	 { (char *)"delete_RegistID", _wrap_delete_RegistID, METH_VARARGS, NULL},
	 { (char *)"RegistID_swigregister", RegistID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CrossID", _wrap_new_CrossID, METH_VARARGS, NULL},
	 { (char *)"delete_CrossID", _wrap_delete_CrossID, METH_VARARGS, NULL},
	 { (char *)"CrossID_swigregister", CrossID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoExecs", _wrap_new_NoExecs, METH_VARARGS, NULL},
	 { (char *)"delete_NoExecs", _wrap_delete_NoExecs, METH_VARARGS, NULL},
	 { (char *)"NoExecs_swigregister", NoExecs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSecurityGroup", _wrap_new_DerivativeSecurityGroup, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSecurityGroup", _wrap_delete_DerivativeSecurityGroup, METH_VARARGS, NULL},
	 { (char *)"DerivativeSecurityGroup_swigregister", DerivativeSecurityGroup_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryDisplayQty", _wrap_new_SecondaryDisplayQty, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryDisplayQty", _wrap_delete_SecondaryDisplayQty, METH_VARARGS, NULL},
	 { (char *)"SecondaryDisplayQty_swigregister", SecondaryDisplayQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefMsgType", _wrap_new_RefMsgType, METH_VARARGS, NULL},
	 { (char *)"delete_RefMsgType", _wrap_delete_RefMsgType, METH_VARARGS, NULL},
	 { (char *)"RefMsgType_swigregister", RefMsgType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StandInstDbID", _wrap_new_StandInstDbID, METH_VARARGS, NULL},
	 { (char *)"delete_StandInstDbID", _wrap_delete_StandInstDbID, METH_VARARGS, NULL},
	 { (char *)"StandInstDbID_swigregister", StandInstDbID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedLegSecurityDescLen", _wrap_new_EncodedLegSecurityDescLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedLegSecurityDescLen", _wrap_delete_EncodedLegSecurityDescLen, METH_VARARGS, NULL},
	 { (char *)"EncodedLegSecurityDescLen_swigregister", EncodedLegSecurityDescLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeEventPx", _wrap_new_DerivativeEventPx, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeEventPx", _wrap_delete_DerivativeEventPx, METH_VARARGS, NULL},
	 { (char *)"DerivativeEventPx_swigregister", DerivativeEventPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlObligSource", _wrap_new_SettlObligSource, METH_VARARGS, NULL},
	 { (char *)"delete_SettlObligSource", _wrap_delete_SettlObligSource, METH_VARARGS, NULL},
	 { (char *)"SettlObligSource_swigregister", SettlObligSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TrdSubType", _wrap_new_TrdSubType, METH_VARARGS, NULL},
	 { (char *)"delete_TrdSubType", _wrap_delete_TrdSubType, METH_VARARGS, NULL},
	 { (char *)"TrdSubType_swigregister", TrdSubType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedUnderlyingIssuerLen", _wrap_new_EncodedUnderlyingIssuerLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedUnderlyingIssuerLen", _wrap_delete_EncodedUnderlyingIssuerLen, METH_VARARGS, NULL},
	 { (char *)"EncodedUnderlyingIssuerLen_swigregister", EncodedUnderlyingIssuerLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExecTransType", _wrap_new_ExecTransType, METH_VARARGS, NULL},
	 { (char *)"delete_ExecTransType", _wrap_delete_ExecTransType, METH_VARARGS, NULL},
	 { (char *)"ExecTransType_swigregister", ExecTransType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BeginSeqNo", _wrap_new_BeginSeqNo, METH_VARARGS, NULL},
	 { (char *)"delete_BeginSeqNo", _wrap_delete_BeginSeqNo, METH_VARARGS, NULL},
	 { (char *)"BeginSeqNo_swigregister", BeginSeqNo_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DayBookingInst", _wrap_new_DayBookingInst, METH_VARARGS, NULL},
	 { (char *)"delete_DayBookingInst", _wrap_delete_DayBookingInst, METH_VARARGS, NULL},
	 { (char *)"DayBookingInst_swigregister", DayBookingInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FlowScheduleType", _wrap_new_FlowScheduleType, METH_VARARGS, NULL},
	 { (char *)"delete_FlowScheduleType", _wrap_delete_FlowScheduleType, METH_VARARGS, NULL},
	 { (char *)"FlowScheduleType_swigregister", FlowScheduleType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDOriginType", _wrap_new_MDOriginType, METH_VARARGS, NULL},
	 { (char *)"delete_MDOriginType", _wrap_delete_MDOriginType, METH_VARARGS, NULL},
	 { (char *)"MDOriginType_swigregister", MDOriginType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollInquiryStatus", _wrap_new_CollInquiryStatus, METH_VARARGS, NULL},
	 { (char *)"delete_CollInquiryStatus", _wrap_delete_CollInquiryStatus, METH_VARARGS, NULL},
	 { (char *)"CollInquiryStatus_swigregister", CollInquiryStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoInstrAttrib", _wrap_new_NoInstrAttrib, METH_VARARGS, NULL},
	 { (char *)"delete_NoInstrAttrib", _wrap_delete_NoInstrAttrib, METH_VARARGS, NULL},
	 { (char *)"NoInstrAttrib_swigregister", NoInstrAttrib_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RegistEmail", _wrap_new_RegistEmail, METH_VARARGS, NULL},
	 { (char *)"delete_RegistEmail", _wrap_delete_RegistEmail, METH_VARARGS, NULL},
	 { (char *)"RegistEmail_swigregister", RegistEmail_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StreamAsgnReqID", _wrap_new_StreamAsgnReqID, METH_VARARGS, NULL},
	 { (char *)"delete_StreamAsgnReqID", _wrap_delete_StreamAsgnReqID, METH_VARARGS, NULL},
	 { (char *)"StreamAsgnReqID_swigregister", StreamAsgnReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CPProgram", _wrap_new_CPProgram, METH_VARARGS, NULL},
	 { (char *)"delete_CPProgram", _wrap_delete_CPProgram, METH_VARARGS, NULL},
	 { (char *)"CPProgram_swigregister", CPProgram_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ConfirmReqID", _wrap_new_ConfirmReqID, METH_VARARGS, NULL},
	 { (char *)"delete_ConfirmReqID", _wrap_delete_ConfirmReqID, METH_VARARGS, NULL},
	 { (char *)"ConfirmReqID_swigregister", ConfirmReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AltMDSourceID", _wrap_new_AltMDSourceID, METH_VARARGS, NULL},
	 { (char *)"delete_AltMDSourceID", _wrap_delete_AltMDSourceID, METH_VARARGS, NULL},
	 { (char *)"AltMDSourceID_swigregister", AltMDSourceID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoOrders", _wrap_new_NoOrders, METH_VARARGS, NULL},
	 { (char *)"delete_NoOrders", _wrap_delete_NoOrders, METH_VARARGS, NULL},
	 { (char *)"NoOrders_swigregister", NoOrders_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashDistribAgentAcctName", _wrap_new_CashDistribAgentAcctName, METH_VARARGS, NULL},
	 { (char *)"delete_CashDistribAgentAcctName", _wrap_delete_CashDistribAgentAcctName, METH_VARARGS, NULL},
	 { (char *)"CashDistribAgentAcctName_swigregister", CashDistribAgentAcctName_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UndlyInstrumentPartyIDSource", _wrap_new_UndlyInstrumentPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_UndlyInstrumentPartyIDSource", _wrap_delete_UndlyInstrumentPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"UndlyInstrumentPartyIDSource_swigregister", UndlyInstrumentPartyIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSettlMethod", _wrap_new_UnderlyingSettlMethod, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSettlMethod", _wrap_delete_UnderlyingSettlMethod, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSettlMethod_swigregister", UnderlyingSettlMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoMDEntryTypes", _wrap_new_NoMDEntryTypes, METH_VARARGS, NULL},
	 { (char *)"delete_NoMDEntryTypes", _wrap_delete_NoMDEntryTypes, METH_VARARGS, NULL},
	 { (char *)"NoMDEntryTypes_swigregister", NoMDEntryTypes_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDEntryForwardPoints", _wrap_new_MDEntryForwardPoints, METH_VARARGS, NULL},
	 { (char *)"delete_MDEntryForwardPoints", _wrap_delete_MDEntryForwardPoints, METH_VARARGS, NULL},
	 { (char *)"MDEntryForwardPoints_swigregister", MDEntryForwardPoints_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PosReqType", _wrap_new_PosReqType, METH_VARARGS, NULL},
	 { (char *)"delete_PosReqType", _wrap_delete_PosReqType, METH_VARARGS, NULL},
	 { (char *)"PosReqType_swigregister", PosReqType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MassStatusReqType", _wrap_new_MassStatusReqType, METH_VARARGS, NULL},
	 { (char *)"delete_MassStatusReqType", _wrap_delete_MassStatusReqType, METH_VARARGS, NULL},
	 { (char *)"MassStatusReqType_swigregister", MassStatusReqType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeOriginationDate", _wrap_new_TradeOriginationDate, METH_VARARGS, NULL},
	 { (char *)"delete_TradeOriginationDate", _wrap_delete_TradeOriginationDate, METH_VARARGS, NULL},
	 { (char *)"TradeOriginationDate_swigregister", TradeOriginationDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlPrice", _wrap_new_SettlPrice, METH_VARARGS, NULL},
	 { (char *)"delete_SettlPrice", _wrap_delete_SettlPrice, METH_VARARGS, NULL},
	 { (char *)"SettlPrice_swigregister", SettlPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecuritySettlAgentAcctName", _wrap_new_SecuritySettlAgentAcctName, METH_VARARGS, NULL},
	 { (char *)"delete_SecuritySettlAgentAcctName", _wrap_delete_SecuritySettlAgentAcctName, METH_VARARGS, NULL},
	 { (char *)"SecuritySettlAgentAcctName_swigregister", SecuritySettlAgentAcctName_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoDerivativeEvents", _wrap_new_NoDerivativeEvents, METH_VARARGS, NULL},
	 { (char *)"delete_NoDerivativeEvents", _wrap_delete_NoDerivativeEvents, METH_VARARGS, NULL},
	 { (char *)"NoDerivativeEvents_swigregister", NoDerivativeEvents_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingEndPrice", _wrap_new_UnderlyingEndPrice, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingEndPrice", _wrap_delete_UnderlyingEndPrice, METH_VARARGS, NULL},
	 { (char *)"UnderlyingEndPrice_swigregister", UnderlyingEndPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SubscriptionRequestType", _wrap_new_SubscriptionRequestType, METH_VARARGS, NULL},
	 { (char *)"delete_SubscriptionRequestType", _wrap_delete_SubscriptionRequestType, METH_VARARGS, NULL},
	 { (char *)"SubscriptionRequestType_swigregister", SubscriptionRequestType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotalNumSecurityTypes", _wrap_new_TotalNumSecurityTypes, METH_VARARGS, NULL},
	 { (char *)"delete_TotalNumSecurityTypes", _wrap_delete_TotalNumSecurityTypes, METH_VARARGS, NULL},
	 { (char *)"TotalNumSecurityTypes_swigregister", TotalNumSecurityTypes_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NewsCategory", _wrap_new_NewsCategory, METH_VARARGS, NULL},
	 { (char *)"delete_NewsCategory", _wrap_delete_NewsCategory, METH_VARARGS, NULL},
	 { (char *)"NewsCategory_swigregister", NewsCategory_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegPutOrCall", _wrap_new_UnderlyingLegPutOrCall, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegPutOrCall", _wrap_delete_UnderlyingLegPutOrCall, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegPutOrCall_swigregister", UnderlyingLegPutOrCall_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_URLLink", _wrap_new_URLLink, METH_VARARGS, NULL},
	 { (char *)"delete_URLLink", _wrap_delete_URLLink, METH_VARARGS, NULL},
	 { (char *)"URLLink_swigregister", URLLink_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoInstrumentPartySubIDs", _wrap_new_NoInstrumentPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoInstrumentPartySubIDs", _wrap_delete_NoInstrumentPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"NoInstrumentPartySubIDs_swigregister", NoInstrumentPartySubIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingCurrentValue", _wrap_new_UnderlyingCurrentValue, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingCurrentValue", _wrap_delete_UnderlyingCurrentValue, METH_VARARGS, NULL},
	 { (char *)"UnderlyingCurrentValue_swigregister", UnderlyingCurrentValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InterestAccrualDate", _wrap_new_InterestAccrualDate, METH_VARARGS, NULL},
	 { (char *)"delete_InterestAccrualDate", _wrap_delete_InterestAccrualDate, METH_VARARGS, NULL},
	 { (char *)"InterestAccrualDate_swigregister", InterestAccrualDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FutSettDate2", _wrap_new_FutSettDate2, METH_VARARGS, NULL},
	 { (char *)"delete_FutSettDate2", _wrap_delete_FutSettDate2, METH_VARARGS, NULL},
	 { (char *)"FutSettDate2_swigregister", FutSettDate2_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoClearingInstructions", _wrap_new_NoClearingInstructions, METH_VARARGS, NULL},
	 { (char *)"delete_NoClearingInstructions", _wrap_delete_NoClearingInstructions, METH_VARARGS, NULL},
	 { (char *)"NoClearingInstructions_swigregister", NoClearingInstructions_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingCurrency", _wrap_new_UnderlyingCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingCurrency", _wrap_delete_UnderlyingCurrency, METH_VARARGS, NULL},
	 { (char *)"UnderlyingCurrency_swigregister", UnderlyingCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegInterestAccrualDate", _wrap_new_LegInterestAccrualDate, METH_VARARGS, NULL},
	 { (char *)"delete_LegInterestAccrualDate", _wrap_delete_LegInterestAccrualDate, METH_VARARGS, NULL},
	 { (char *)"LegInterestAccrualDate_swigregister", LegInterestAccrualDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NewPassword", _wrap_new_NewPassword, METH_VARARGS, NULL},
	 { (char *)"delete_NewPassword", _wrap_delete_NewPassword, METH_VARARGS, NULL},
	 { (char *)"NewPassword_swigregister", NewPassword_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RedemptionDate", _wrap_new_RedemptionDate, METH_VARARGS, NULL},
	 { (char *)"delete_RedemptionDate", _wrap_delete_RedemptionDate, METH_VARARGS, NULL},
	 { (char *)"RedemptionDate_swigregister", RedemptionDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefApplLastSeqNum", _wrap_new_RefApplLastSeqNum, METH_VARARGS, NULL},
	 { (char *)"delete_RefApplLastSeqNum", _wrap_delete_RefApplLastSeqNum, METH_VARARGS, NULL},
	 { (char *)"RefApplLastSeqNum_swigregister", RefApplLastSeqNum_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StartCash", _wrap_new_StartCash, METH_VARARGS, NULL},
	 { (char *)"delete_StartCash", _wrap_delete_StartCash, METH_VARARGS, NULL},
	 { (char *)"StartCash_swigregister", StartCash_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaxMessageSize", _wrap_new_MaxMessageSize, METH_VARARGS, NULL},
	 { (char *)"delete_MaxMessageSize", _wrap_delete_MaxMessageSize, METH_VARARGS, NULL},
	 { (char *)"MaxMessageSize_swigregister", MaxMessageSize_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OfferForwardPoints", _wrap_new_OfferForwardPoints, METH_VARARGS, NULL},
	 { (char *)"delete_OfferForwardPoints", _wrap_delete_OfferForwardPoints, METH_VARARGS, NULL},
	 { (char *)"OfferForwardPoints_swigregister", OfferForwardPoints_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IOIQty", _wrap_new_IOIQty, METH_VARARGS, NULL},
	 { (char *)"delete_IOIQty", _wrap_delete_IOIQty, METH_VARARGS, NULL},
	 { (char *)"IOIQty_swigregister", IOIQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastQty", _wrap_new_LastQty, METH_VARARGS, NULL},
	 { (char *)"delete_LastQty", _wrap_delete_LastQty, METH_VARARGS, NULL},
	 { (char *)"LastQty_swigregister", LastQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplResponseError", _wrap_new_ApplResponseError, METH_VARARGS, NULL},
	 { (char *)"delete_ApplResponseError", _wrap_delete_ApplResponseError, METH_VARARGS, NULL},
	 { (char *)"ApplResponseError_swigregister", ApplResponseError_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegSecurityType", _wrap_new_UnderlyingLegSecurityType, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegSecurityType", _wrap_delete_UnderlyingLegSecurityType, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegSecurityType_swigregister", UnderlyingLegSecurityType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativePriceUnitOfMeasure", _wrap_new_DerivativePriceUnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativePriceUnitOfMeasure", _wrap_delete_DerivativePriceUnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"DerivativePriceUnitOfMeasure_swigregister", DerivativePriceUnitOfMeasure_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerPriceDirection", _wrap_new_TriggerPriceDirection, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerPriceDirection", _wrap_delete_TriggerPriceDirection, METH_VARARGS, NULL},
	 { (char *)"TriggerPriceDirection_swigregister", TriggerPriceDirection_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PositionCurrency", _wrap_new_PositionCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_PositionCurrency", _wrap_delete_PositionCurrency, METH_VARARGS, NULL},
	 { (char *)"PositionCurrency_swigregister", PositionCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MessageEventSource", _wrap_new_MessageEventSource, METH_VARARGS, NULL},
	 { (char *)"delete_MessageEventSource", _wrap_delete_MessageEventSource, METH_VARARGS, NULL},
	 { (char *)"MessageEventSource_swigregister", MessageEventSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollInquiryID", _wrap_new_CollInquiryID, METH_VARARGS, NULL},
	 { (char *)"delete_CollInquiryID", _wrap_delete_CollInquiryID, METH_VARARGS, NULL},
	 { (char *)"CollInquiryID_swigregister", CollInquiryID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingStartValue", _wrap_new_UnderlyingStartValue, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingStartValue", _wrap_delete_UnderlyingStartValue, METH_VARARGS, NULL},
	 { (char *)"UnderlyingStartValue_swigregister", UnderlyingStartValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastLiquidityInd", _wrap_new_LastLiquidityInd, METH_VARARGS, NULL},
	 { (char *)"delete_LastLiquidityInd", _wrap_delete_LastLiquidityInd, METH_VARARGS, NULL},
	 { (char *)"LastLiquidityInd_swigregister", LastLiquidityInd_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityID", _wrap_new_SecurityID, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityID", _wrap_delete_SecurityID, METH_VARARGS, NULL},
	 { (char *)"SecurityID_swigregister", SecurityID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoMDEntries", _wrap_new_NoMDEntries, METH_VARARGS, NULL},
	 { (char *)"delete_NoMDEntries", _wrap_delete_NoMDEntries, METH_VARARGS, NULL},
	 { (char *)"NoMDEntries_swigregister", NoMDEntries_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StrikePriceDeterminationMethod", _wrap_new_StrikePriceDeterminationMethod, METH_VARARGS, NULL},
	 { (char *)"delete_StrikePriceDeterminationMethod", _wrap_delete_StrikePriceDeterminationMethod, METH_VARARGS, NULL},
	 { (char *)"StrikePriceDeterminationMethod_swigregister", StrikePriceDeterminationMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EndDate", _wrap_new_EndDate, METH_VARARGS, NULL},
	 { (char *)"delete_EndDate", _wrap_delete_EndDate, METH_VARARGS, NULL},
	 { (char *)"EndDate_swigregister", EndDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashOutstanding", _wrap_new_CashOutstanding, METH_VARARGS, NULL},
	 { (char *)"delete_CashOutstanding", _wrap_delete_CashOutstanding, METH_VARARGS, NULL},
	 { (char *)"CashOutstanding_swigregister", CashOutstanding_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDReqID", _wrap_new_MDReqID, METH_VARARGS, NULL},
	 { (char *)"delete_MDReqID", _wrap_delete_MDReqID, METH_VARARGS, NULL},
	 { (char *)"MDReqID_swigregister", MDReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IOIRefID", _wrap_new_IOIRefID, METH_VARARGS, NULL},
	 { (char *)"delete_IOIRefID", _wrap_delete_IOIRefID, METH_VARARGS, NULL},
	 { (char *)"IOIRefID_swigregister", IOIRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TargetStrategy", _wrap_new_TargetStrategy, METH_VARARGS, NULL},
	 { (char *)"delete_TargetStrategy", _wrap_delete_TargetStrategy, METH_VARARGS, NULL},
	 { (char *)"TargetStrategy_swigregister", TargetStrategy_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ConfirmRefID", _wrap_new_ConfirmRefID, METH_VARARGS, NULL},
	 { (char *)"delete_ConfirmRefID", _wrap_delete_ConfirmRefID, METH_VARARGS, NULL},
	 { (char *)"ConfirmRefID_swigregister", ConfirmRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SellerDays", _wrap_new_SellerDays, METH_VARARGS, NULL},
	 { (char *)"delete_SellerDays", _wrap_delete_SellerDays, METH_VARARGS, NULL},
	 { (char *)"SellerDays_swigregister", SellerDays_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DueToRelated", _wrap_new_DueToRelated, METH_VARARGS, NULL},
	 { (char *)"delete_DueToRelated", _wrap_delete_DueToRelated, METH_VARARGS, NULL},
	 { (char *)"DueToRelated_swigregister", DueToRelated_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryTradingReferencePrice", _wrap_new_SecondaryTradingReferencePrice, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryTradingReferencePrice", _wrap_delete_SecondaryTradingReferencePrice, METH_VARARGS, NULL},
	 { (char *)"SecondaryTradingReferencePrice_swigregister", SecondaryTradingReferencePrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoMDFeedTypes", _wrap_new_NoMDFeedTypes, METH_VARARGS, NULL},
	 { (char *)"delete_NoMDFeedTypes", _wrap_delete_NoMDFeedTypes, METH_VARARGS, NULL},
	 { (char *)"NoMDFeedTypes_swigregister", NoMDFeedTypes_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingInstrumentPartySubIDType", _wrap_new_UnderlyingInstrumentPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingInstrumentPartySubIDType", _wrap_delete_UnderlyingInstrumentPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"UnderlyingInstrumentPartySubIDType_swigregister", UnderlyingInstrumentPartySubIDType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradSesCloseTime", _wrap_new_TradSesCloseTime, METH_VARARGS, NULL},
	 { (char *)"delete_TradSesCloseTime", _wrap_delete_TradSesCloseTime, METH_VARARGS, NULL},
	 { (char *)"TradSesCloseTime_swigregister", TradSesCloseTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ContractSettlMonth", _wrap_new_ContractSettlMonth, METH_VARARGS, NULL},
	 { (char *)"delete_ContractSettlMonth", _wrap_delete_ContractSettlMonth, METH_VARARGS, NULL},
	 { (char *)"ContractSettlMonth_swigregister", ContractSettlMonth_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeStrikePrice", _wrap_new_DerivativeStrikePrice, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeStrikePrice", _wrap_delete_DerivativeStrikePrice, METH_VARARGS, NULL},
	 { (char *)"DerivativeStrikePrice_swigregister", DerivativeStrikePrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerSecurityDesc", _wrap_new_TriggerSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerSecurityDesc", _wrap_delete_TriggerSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"TriggerSecurityDesc_swigregister", TriggerSecurityDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingCashType", _wrap_new_UnderlyingCashType, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingCashType", _wrap_delete_UnderlyingCashType, METH_VARARGS, NULL},
	 { (char *)"UnderlyingCashType_swigregister", UnderlyingCashType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoMiscFees", _wrap_new_NoMiscFees, METH_VARARGS, NULL},
	 { (char *)"delete_NoMiscFees", _wrap_delete_NoMiscFees, METH_VARARGS, NULL},
	 { (char *)"NoMiscFees_swigregister", NoMiscFees_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CustOrderCapacity", _wrap_new_CustOrderCapacity, METH_VARARGS, NULL},
	 { (char *)"delete_CustOrderCapacity", _wrap_delete_CustOrderCapacity, METH_VARARGS, NULL},
	 { (char *)"CustOrderCapacity_swigregister", CustOrderCapacity_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegAllocSettlCurrency", _wrap_new_LegAllocSettlCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_LegAllocSettlCurrency", _wrap_delete_LegAllocSettlCurrency, METH_VARARGS, NULL},
	 { (char *)"LegAllocSettlCurrency_swigregister", LegAllocSettlCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingAdjustedQuantity", _wrap_new_UnderlyingAdjustedQuantity, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingAdjustedQuantity", _wrap_delete_UnderlyingAdjustedQuantity, METH_VARARGS, NULL},
	 { (char *)"UnderlyingAdjustedQuantity_swigregister", UnderlyingAdjustedQuantity_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OwnershipType", _wrap_new_OwnershipType, METH_VARARGS, NULL},
	 { (char *)"delete_OwnershipType", _wrap_delete_OwnershipType, METH_VARARGS, NULL},
	 { (char *)"OwnershipType_swigregister", OwnershipType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaxShow", _wrap_new_MaxShow, METH_VARARGS, NULL},
	 { (char *)"delete_MaxShow", _wrap_delete_MaxShow, METH_VARARGS, NULL},
	 { (char *)"MaxShow_swigregister", MaxShow_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSecurityID", _wrap_new_LegSecurityID, METH_VARARGS, NULL},
	 { (char *)"delete_LegSecurityID", _wrap_delete_LegSecurityID, METH_VARARGS, NULL},
	 { (char *)"LegSecurityID_swigregister", LegSecurityID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSecurityDesc", _wrap_new_DerivativeSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSecurityDesc", _wrap_delete_DerivativeSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"DerivativeSecurityDesc_swigregister", DerivativeSecurityDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnitOfMeasure", _wrap_new_UnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"delete_UnitOfMeasure", _wrap_delete_UnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"UnitOfMeasure_swigregister", UnitOfMeasure_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Quantity", _wrap_new_Quantity, METH_VARARGS, NULL},
	 { (char *)"delete_Quantity", _wrap_delete_Quantity, METH_VARARGS, NULL},
	 { (char *)"Quantity_swigregister", Quantity_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NewsID", _wrap_new_NewsID, METH_VARARGS, NULL},
	 { (char *)"delete_NewsID", _wrap_delete_NewsID, METH_VARARGS, NULL},
	 { (char *)"NewsID_swigregister", NewsID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UndlyInstrumentPartySubIDType", _wrap_new_UndlyInstrumentPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_UndlyInstrumentPartySubIDType", _wrap_delete_UndlyInstrumentPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"UndlyInstrumentPartySubIDType_swigregister", UndlyInstrumentPartySubIDType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettleOnOpenFlag", _wrap_new_SettleOnOpenFlag, METH_VARARGS, NULL},
	 { (char *)"delete_SettleOnOpenFlag", _wrap_delete_SettleOnOpenFlag, METH_VARARGS, NULL},
	 { (char *)"SettleOnOpenFlag_swigregister", SettleOnOpenFlag_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastUpdateTime", _wrap_new_LastUpdateTime, METH_VARARGS, NULL},
	 { (char *)"delete_LastUpdateTime", _wrap_delete_LastUpdateTime, METH_VARARGS, NULL},
	 { (char *)"LastUpdateTime_swigregister", LastUpdateTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RepurchaseRate", _wrap_new_RepurchaseRate, METH_VARARGS, NULL},
	 { (char *)"delete_RepurchaseRate", _wrap_delete_RepurchaseRate, METH_VARARGS, NULL},
	 { (char *)"RepurchaseRate_swigregister", RepurchaseRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RepurchaseTerm", _wrap_new_RepurchaseTerm, METH_VARARGS, NULL},
	 { (char *)"delete_RepurchaseTerm", _wrap_delete_RepurchaseTerm, METH_VARARGS, NULL},
	 { (char *)"RepurchaseTerm_swigregister", RepurchaseTerm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NestedPartyRole", _wrap_new_NestedPartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_NestedPartyRole", _wrap_delete_NestedPartyRole, METH_VARARGS, NULL},
	 { (char *)"NestedPartyRole_swigregister", NestedPartyRole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryExecID", _wrap_new_SecondaryExecID, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryExecID", _wrap_delete_SecondaryExecID, METH_VARARGS, NULL},
	 { (char *)"SecondaryExecID_swigregister", SecondaryExecID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Pool", _wrap_new_Pool, METH_VARARGS, NULL},
	 { (char *)"delete_Pool", _wrap_delete_Pool, METH_VARARGS, NULL},
	 { (char *)"Pool_swigregister", Pool_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoTickRules", _wrap_new_NoTickRules, METH_VARARGS, NULL},
	 { (char *)"delete_NoTickRules", _wrap_delete_NoTickRules, METH_VARARGS, NULL},
	 { (char *)"NoTickRules_swigregister", NoTickRules_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Volatility", _wrap_new_Volatility, METH_VARARGS, NULL},
	 { (char *)"delete_Volatility", _wrap_delete_Volatility, METH_VARARGS, NULL},
	 { (char *)"Volatility_swigregister", Volatility_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PctAtRisk", _wrap_new_PctAtRisk, METH_VARARGS, NULL},
	 { (char *)"delete_PctAtRisk", _wrap_delete_PctAtRisk, METH_VARARGS, NULL},
	 { (char *)"PctAtRisk_swigregister", PctAtRisk_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSecurityExchange", _wrap_new_UnderlyingSecurityExchange, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSecurityExchange", _wrap_delete_UnderlyingSecurityExchange, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSecurityExchange_swigregister", UnderlyingSecurityExchange_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegStrikePrice", _wrap_new_LegStrikePrice, METH_VARARGS, NULL},
	 { (char *)"delete_LegStrikePrice", _wrap_delete_LegStrikePrice, METH_VARARGS, NULL},
	 { (char *)"LegStrikePrice_swigregister", LegStrikePrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlmntTyp", _wrap_new_SettlmntTyp, METH_VARARGS, NULL},
	 { (char *)"delete_SettlmntTyp", _wrap_delete_SettlmntTyp, METH_VARARGS, NULL},
	 { (char *)"SettlmntTyp_swigregister", SettlmntTyp_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradePublishIndicator", _wrap_new_TradePublishIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_TradePublishIndicator", _wrap_delete_TradePublishIndicator, METH_VARARGS, NULL},
	 { (char *)"TradePublishIndicator_swigregister", TradePublishIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplResponseType", _wrap_new_ApplResponseType, METH_VARARGS, NULL},
	 { (char *)"delete_ApplResponseType", _wrap_delete_ApplResponseType, METH_VARARGS, NULL},
	 { (char *)"ApplResponseType_swigregister", ApplResponseType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDSubBookType", _wrap_new_MDSubBookType, METH_VARARGS, NULL},
	 { (char *)"delete_MDSubBookType", _wrap_delete_MDSubBookType, METH_VARARGS, NULL},
	 { (char *)"MDSubBookType_swigregister", MDSubBookType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Username", _wrap_new_Username, METH_VARARGS, NULL},
	 { (char *)"delete_Username", _wrap_delete_Username, METH_VARARGS, NULL},
	 { (char *)"Username_swigregister", Username_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StandInstDbType", _wrap_new_StandInstDbType, METH_VARARGS, NULL},
	 { (char *)"delete_StandInstDbType", _wrap_delete_StandInstDbType, METH_VARARGS, NULL},
	 { (char *)"StandInstDbType_swigregister", StandInstDbType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteEntryStatus", _wrap_new_QuoteEntryStatus, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteEntryStatus", _wrap_delete_QuoteEntryStatus, METH_VARARGS, NULL},
	 { (char *)"QuoteEntryStatus_swigregister", QuoteEntryStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerPriceType", _wrap_new_TriggerPriceType, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerPriceType", _wrap_delete_TriggerPriceType, METH_VARARGS, NULL},
	 { (char *)"TriggerPriceType_swigregister", TriggerPriceType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideTrdSubTyp", _wrap_new_SideTrdSubTyp, METH_VARARGS, NULL},
	 { (char *)"delete_SideTrdSubTyp", _wrap_delete_SideTrdSubTyp, METH_VARARGS, NULL},
	 { (char *)"SideTrdSubTyp_swigregister", SideTrdSubTyp_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingTradingSessionSubID", _wrap_new_UnderlyingTradingSessionSubID, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingTradingSessionSubID", _wrap_delete_UnderlyingTradingSessionSubID, METH_VARARGS, NULL},
	 { (char *)"UnderlyingTradingSessionSubID_swigregister", UnderlyingTradingSessionSubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlInstReqRejCode", _wrap_new_SettlInstReqRejCode, METH_VARARGS, NULL},
	 { (char *)"delete_SettlInstReqRejCode", _wrap_delete_SettlInstReqRejCode, METH_VARARGS, NULL},
	 { (char *)"SettlInstReqRejCode_swigregister", SettlInstReqRejCode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MktBidPx", _wrap_new_MktBidPx, METH_VARARGS, NULL},
	 { (char *)"delete_MktBidPx", _wrap_delete_MktBidPx, METH_VARARGS, NULL},
	 { (char *)"MktBidPx_swigregister", MktBidPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegSymbol", _wrap_new_UnderlyingLegSymbol, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegSymbol", _wrap_delete_UnderlyingLegSymbol, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegSymbol_swigregister", UnderlyingLegSymbol_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StrikeValue", _wrap_new_StrikeValue, METH_VARARGS, NULL},
	 { (char *)"delete_StrikeValue", _wrap_delete_StrikeValue, METH_VARARGS, NULL},
	 { (char *)"StrikeValue_swigregister", StrikeValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Urgency", _wrap_new_Urgency, METH_VARARGS, NULL},
	 { (char *)"delete_Urgency", _wrap_delete_Urgency, METH_VARARGS, NULL},
	 { (char *)"Urgency_swigregister", Urgency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocID", _wrap_new_AllocID, METH_VARARGS, NULL},
	 { (char *)"delete_AllocID", _wrap_delete_AllocID, METH_VARARGS, NULL},
	 { (char *)"AllocID_swigregister", AllocID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingDeliveryAmount", _wrap_new_UnderlyingDeliveryAmount, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingDeliveryAmount", _wrap_delete_UnderlyingDeliveryAmount, METH_VARARGS, NULL},
	 { (char *)"UnderlyingDeliveryAmount_swigregister", UnderlyingDeliveryAmount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideQty", _wrap_new_SideQty, METH_VARARGS, NULL},
	 { (char *)"delete_SideQty", _wrap_delete_SideQty, METH_VARARGS, NULL},
	 { (char *)"SideQty_swigregister", SideQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollAsgnTransType", _wrap_new_CollAsgnTransType, METH_VARARGS, NULL},
	 { (char *)"delete_CollAsgnTransType", _wrap_delete_CollAsgnTransType, METH_VARARGS, NULL},
	 { (char *)"CollAsgnTransType_swigregister", CollAsgnTransType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ThresholdAmount", _wrap_new_ThresholdAmount, METH_VARARGS, NULL},
	 { (char *)"delete_ThresholdAmount", _wrap_delete_ThresholdAmount, METH_VARARGS, NULL},
	 { (char *)"ThresholdAmount_swigregister", ThresholdAmount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DefBidSize", _wrap_new_DefBidSize, METH_VARARGS, NULL},
	 { (char *)"delete_DefBidSize", _wrap_delete_DefBidSize, METH_VARARGS, NULL},
	 { (char *)"DefBidSize_swigregister", DefBidSize_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegStateOrProvinceOfIssue", _wrap_new_LegStateOrProvinceOfIssue, METH_VARARGS, NULL},
	 { (char *)"delete_LegStateOrProvinceOfIssue", _wrap_delete_LegStateOrProvinceOfIssue, METH_VARARGS, NULL},
	 { (char *)"LegStateOrProvinceOfIssue_swigregister", LegStateOrProvinceOfIssue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PaymentMethod", _wrap_new_PaymentMethod, METH_VARARGS, NULL},
	 { (char *)"delete_PaymentMethod", _wrap_delete_PaymentMethod, METH_VARARGS, NULL},
	 { (char *)"PaymentMethod_swigregister", PaymentMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegOptAttribute", _wrap_new_UnderlyingLegOptAttribute, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegOptAttribute", _wrap_delete_UnderlyingLegOptAttribute, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegOptAttribute_swigregister", UnderlyingLegOptAttribute_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegVolatility", _wrap_new_LegVolatility, METH_VARARGS, NULL},
	 { (char *)"delete_LegVolatility", _wrap_delete_LegVolatility, METH_VARARGS, NULL},
	 { (char *)"LegVolatility_swigregister", LegVolatility_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeInstrAttribType", _wrap_new_DerivativeInstrAttribType, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeInstrAttribType", _wrap_delete_DerivativeInstrAttribType, METH_VARARGS, NULL},
	 { (char *)"DerivativeInstrAttribType_swigregister", DerivativeInstrAttribType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeUnitOfMeasureQty", _wrap_new_DerivativeUnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeUnitOfMeasureQty", _wrap_delete_DerivativeUnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"DerivativeUnitOfMeasureQty_swigregister", DerivativeUnitOfMeasureQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoStatsIndicators", _wrap_new_NoStatsIndicators, METH_VARARGS, NULL},
	 { (char *)"delete_NoStatsIndicators", _wrap_delete_NoStatsIndicators, METH_VARARGS, NULL},
	 { (char *)"NoStatsIndicators_swigregister", NoStatsIndicators_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerPriceTypeScope", _wrap_new_TriggerPriceTypeScope, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerPriceTypeScope", _wrap_delete_TriggerPriceTypeScope, METH_VARARGS, NULL},
	 { (char *)"TriggerPriceTypeScope_swigregister", TriggerPriceTypeScope_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastNetworkResponseID", _wrap_new_LastNetworkResponseID, METH_VARARGS, NULL},
	 { (char *)"delete_LastNetworkResponseID", _wrap_delete_LastNetworkResponseID, METH_VARARGS, NULL},
	 { (char *)"LastNetworkResponseID_swigregister", LastNetworkResponseID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSettlPriceType", _wrap_new_UnderlyingSettlPriceType, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSettlPriceType", _wrap_delete_UnderlyingSettlPriceType, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSettlPriceType_swigregister", UnderlyingSettlPriceType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplReportID", _wrap_new_ApplReportID, METH_VARARGS, NULL},
	 { (char *)"delete_ApplReportID", _wrap_delete_ApplReportID, METH_VARARGS, NULL},
	 { (char *)"ApplReportID_swigregister", ApplReportID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PegLimitType", _wrap_new_PegLimitType, METH_VARARGS, NULL},
	 { (char *)"delete_PegLimitType", _wrap_delete_PegLimitType, METH_VARARGS, NULL},
	 { (char *)"PegLimitType_swigregister", PegLimitType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExecID", _wrap_new_ExecID, METH_VARARGS, NULL},
	 { (char *)"delete_ExecID", _wrap_delete_ExecID, METH_VARARGS, NULL},
	 { (char *)"ExecID_swigregister", ExecID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Side", _wrap_new_Side, METH_VARARGS, NULL},
	 { (char *)"delete_Side", _wrap_delete_Side, METH_VARARGS, NULL},
	 { (char *)"Side_swigregister", Side_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLastPx", _wrap_new_UnderlyingLastPx, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLastPx", _wrap_delete_UnderlyingLastPx, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLastPx_swigregister", UnderlyingLastPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MarketDepth", _wrap_new_MarketDepth, METH_VARARGS, NULL},
	 { (char *)"delete_MarketDepth", _wrap_delete_MarketDepth, METH_VARARGS, NULL},
	 { (char *)"MarketDepth_swigregister", MarketDepth_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DiscretionOffset", _wrap_new_DiscretionOffset, METH_VARARGS, NULL},
	 { (char *)"delete_DiscretionOffset", _wrap_delete_DiscretionOffset, METH_VARARGS, NULL},
	 { (char *)"DiscretionOffset_swigregister", DiscretionOffset_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ContAmtType", _wrap_new_ContAmtType, METH_VARARGS, NULL},
	 { (char *)"delete_ContAmtType", _wrap_delete_ContAmtType, METH_VARARGS, NULL},
	 { (char *)"ContAmtType_swigregister", ContAmtType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MiscFeeCurr", _wrap_new_MiscFeeCurr, METH_VARARGS, NULL},
	 { (char *)"delete_MiscFeeCurr", _wrap_delete_MiscFeeCurr, METH_VARARGS, NULL},
	 { (char *)"MiscFeeCurr_swigregister", MiscFeeCurr_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AttachmentPoint", _wrap_new_AttachmentPoint, METH_VARARGS, NULL},
	 { (char *)"delete_AttachmentPoint", _wrap_delete_AttachmentPoint, METH_VARARGS, NULL},
	 { (char *)"AttachmentPoint_swigregister", AttachmentPoint_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrderCategory", _wrap_new_OrderCategory, METH_VARARGS, NULL},
	 { (char *)"delete_OrderCategory", _wrap_delete_OrderCategory, METH_VARARGS, NULL},
	 { (char *)"OrderCategory_swigregister", OrderCategory_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AdvTransType", _wrap_new_AdvTransType, METH_VARARGS, NULL},
	 { (char *)"delete_AdvTransType", _wrap_delete_AdvTransType, METH_VARARGS, NULL},
	 { (char *)"AdvTransType_swigregister", AdvTransType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_WtAverageLiquidity", _wrap_new_WtAverageLiquidity, METH_VARARGS, NULL},
	 { (char *)"delete_WtAverageLiquidity", _wrap_delete_WtAverageLiquidity, METH_VARARGS, NULL},
	 { (char *)"WtAverageLiquidity_swigregister", WtAverageLiquidity_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteSetValidUntilTime", _wrap_new_QuoteSetValidUntilTime, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteSetValidUntilTime", _wrap_delete_QuoteSetValidUntilTime, METH_VARARGS, NULL},
	 { (char *)"QuoteSetValidUntilTime_swigregister", QuoteSetValidUntilTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoNested4PartyIDs", _wrap_new_NoNested4PartyIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoNested4PartyIDs", _wrap_delete_NoNested4PartyIDs, METH_VARARGS, NULL},
	 { (char *)"NoNested4PartyIDs_swigregister", NoNested4PartyIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegPutOrCall", _wrap_new_LegPutOrCall, METH_VARARGS, NULL},
	 { (char *)"delete_LegPutOrCall", _wrap_delete_LegPutOrCall, METH_VARARGS, NULL},
	 { (char *)"LegPutOrCall_swigregister", LegPutOrCall_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UserStatusText", _wrap_new_UserStatusText, METH_VARARGS, NULL},
	 { (char *)"delete_UserStatusText", _wrap_delete_UserStatusText, METH_VARARGS, NULL},
	 { (char *)"UserStatusText_swigregister", UserStatusText_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested2PartySubID", _wrap_new_Nested2PartySubID, METH_VARARGS, NULL},
	 { (char *)"delete_Nested2PartySubID", _wrap_delete_Nested2PartySubID, METH_VARARGS, NULL},
	 { (char *)"Nested2PartySubID_swigregister", Nested2PartySubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EFPTrackingError", _wrap_new_EFPTrackingError, METH_VARARGS, NULL},
	 { (char *)"delete_EFPTrackingError", _wrap_delete_EFPTrackingError, METH_VARARGS, NULL},
	 { (char *)"EFPTrackingError_swigregister", EFPTrackingError_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideLiquidityInd", _wrap_new_SideLiquidityInd, METH_VARARGS, NULL},
	 { (char *)"delete_SideLiquidityInd", _wrap_delete_SideLiquidityInd, METH_VARARGS, NULL},
	 { (char *)"SideLiquidityInd_swigregister", SideLiquidityInd_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeMinPriceIncrement", _wrap_new_DerivativeMinPriceIncrement, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeMinPriceIncrement", _wrap_delete_DerivativeMinPriceIncrement, METH_VARARGS, NULL},
	 { (char *)"DerivativeMinPriceIncrement_swigregister", DerivativeMinPriceIncrement_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PublishTrdIndicator", _wrap_new_PublishTrdIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_PublishTrdIndicator", _wrap_delete_PublishTrdIndicator, METH_VARARGS, NULL},
	 { (char *)"PublishTrdIndicator_swigregister", PublishTrdIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InvestorCountryOfResidence", _wrap_new_InvestorCountryOfResidence, METH_VARARGS, NULL},
	 { (char *)"delete_InvestorCountryOfResidence", _wrap_delete_InvestorCountryOfResidence, METH_VARARGS, NULL},
	 { (char *)"InvestorCountryOfResidence_swigregister", InvestorCountryOfResidence_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideReasonCd", _wrap_new_SideReasonCd, METH_VARARGS, NULL},
	 { (char *)"delete_SideReasonCd", _wrap_delete_SideReasonCd, METH_VARARGS, NULL},
	 { (char *)"SideReasonCd_swigregister", SideReasonCd_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MinPriceIncrement", _wrap_new_MinPriceIncrement, METH_VARARGS, NULL},
	 { (char *)"delete_MinPriceIncrement", _wrap_delete_MinPriceIncrement, METH_VARARGS, NULL},
	 { (char *)"MinPriceIncrement_swigregister", MinPriceIncrement_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecuritySettlAgentContactName", _wrap_new_SecuritySettlAgentContactName, METH_VARARGS, NULL},
	 { (char *)"delete_SecuritySettlAgentContactName", _wrap_delete_SecuritySettlAgentContactName, METH_VARARGS, NULL},
	 { (char *)"SecuritySettlAgentContactName_swigregister", SecuritySettlAgentContactName_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityResponseType", _wrap_new_SecurityResponseType, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityResponseType", _wrap_delete_SecurityResponseType, METH_VARARGS, NULL},
	 { (char *)"SecurityResponseType_swigregister", SecurityResponseType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegBenchmarkCurvePoint", _wrap_new_LegBenchmarkCurvePoint, METH_VARARGS, NULL},
	 { (char *)"delete_LegBenchmarkCurvePoint", _wrap_delete_LegBenchmarkCurvePoint, METH_VARARGS, NULL},
	 { (char *)"LegBenchmarkCurvePoint_swigregister", LegBenchmarkCurvePoint_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ClearingFirm", _wrap_new_ClearingFirm, METH_VARARGS, NULL},
	 { (char *)"delete_ClearingFirm", _wrap_delete_ClearingFirm, METH_VARARGS, NULL},
	 { (char *)"ClearingFirm_swigregister", ClearingFirm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SessionStatus", _wrap_new_SessionStatus, METH_VARARGS, NULL},
	 { (char *)"delete_SessionStatus", _wrap_delete_SessionStatus, METH_VARARGS, NULL},
	 { (char *)"SessionStatus_swigregister", SessionStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerSecurityID", _wrap_new_TriggerSecurityID, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerSecurityID", _wrap_delete_TriggerSecurityID, METH_VARARGS, NULL},
	 { (char *)"TriggerSecurityID_swigregister", TriggerSecurityID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotNoAllocs", _wrap_new_TotNoAllocs, METH_VARARGS, NULL},
	 { (char *)"delete_TotNoAllocs", _wrap_delete_TotNoAllocs, METH_VARARGS, NULL},
	 { (char *)"TotNoAllocs_swigregister", TotNoAllocs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoAltMDSource", _wrap_new_NoAltMDSource, METH_VARARGS, NULL},
	 { (char *)"delete_NoAltMDSource", _wrap_delete_NoAltMDSource, METH_VARARGS, NULL},
	 { (char *)"NoAltMDSource_swigregister", NoAltMDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocAccountType", _wrap_new_AllocAccountType, METH_VARARGS, NULL},
	 { (char *)"delete_AllocAccountType", _wrap_delete_AllocAccountType, METH_VARARGS, NULL},
	 { (char *)"AllocAccountType_swigregister", AllocAccountType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastPx", _wrap_new_LastPx, METH_VARARGS, NULL},
	 { (char *)"delete_LastPx", _wrap_delete_LastPx, METH_VARARGS, NULL},
	 { (char *)"LastPx_swigregister", LastPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocTransType", _wrap_new_AllocTransType, METH_VARARGS, NULL},
	 { (char *)"delete_AllocTransType", _wrap_delete_AllocTransType, METH_VARARGS, NULL},
	 { (char *)"AllocTransType_swigregister", AllocTransType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotNoQuoteEntries", _wrap_new_TotNoQuoteEntries, METH_VARARGS, NULL},
	 { (char *)"delete_TotNoQuoteEntries", _wrap_delete_TotNoQuoteEntries, METH_VARARGS, NULL},
	 { (char *)"TotNoQuoteEntries_swigregister", TotNoQuoteEntries_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MinBidSize", _wrap_new_MinBidSize, METH_VARARGS, NULL},
	 { (char *)"delete_MinBidSize", _wrap_delete_MinBidSize, METH_VARARGS, NULL},
	 { (char *)"MinBidSize_swigregister", MinBidSize_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlBrkrCode", _wrap_new_SettlBrkrCode, METH_VARARGS, NULL},
	 { (char *)"delete_SettlBrkrCode", _wrap_delete_SettlBrkrCode, METH_VARARGS, NULL},
	 { (char *)"SettlBrkrCode_swigregister", SettlBrkrCode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CardHolderName", _wrap_new_CardHolderName, METH_VARARGS, NULL},
	 { (char *)"delete_CardHolderName", _wrap_delete_CardHolderName, METH_VARARGS, NULL},
	 { (char *)"CardHolderName_swigregister", CardHolderName_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExpirationQtyType", _wrap_new_ExpirationQtyType, METH_VARARGS, NULL},
	 { (char *)"delete_ExpirationQtyType", _wrap_delete_ExpirationQtyType, METH_VARARGS, NULL},
	 { (char *)"ExpirationQtyType_swigregister", ExpirationQtyType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedUnderlyingSecurityDescLen", _wrap_new_EncodedUnderlyingSecurityDescLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedUnderlyingSecurityDescLen", _wrap_delete_EncodedUnderlyingSecurityDescLen, METH_VARARGS, NULL},
	 { (char *)"EncodedUnderlyingSecurityDescLen_swigregister", EncodedUnderlyingSecurityDescLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteReqID", _wrap_new_QuoteReqID, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteReqID", _wrap_delete_QuoteReqID, METH_VARARGS, NULL},
	 { (char *)"QuoteReqID_swigregister", QuoteReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PriceUnitOfMeasure", _wrap_new_PriceUnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"delete_PriceUnitOfMeasure", _wrap_delete_PriceUnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"PriceUnitOfMeasure_swigregister", PriceUnitOfMeasure_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TZTransactTime", _wrap_new_TZTransactTime, METH_VARARGS, NULL},
	 { (char *)"delete_TZTransactTime", _wrap_delete_TZTransactTime, METH_VARARGS, NULL},
	 { (char *)"TZTransactTime_swigregister", TZTransactTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocHandlInst", _wrap_new_AllocHandlInst, METH_VARARGS, NULL},
	 { (char *)"delete_AllocHandlInst", _wrap_delete_AllocHandlInst, METH_VARARGS, NULL},
	 { (char *)"AllocHandlInst_swigregister", AllocHandlInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingInstrumentPartyIDSource", _wrap_new_UnderlyingInstrumentPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingInstrumentPartyIDSource", _wrap_delete_UnderlyingInstrumentPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"UnderlyingInstrumentPartyIDSource_swigregister", UnderlyingInstrumentPartyIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CurrencyRatio", _wrap_new_CurrencyRatio, METH_VARARGS, NULL},
	 { (char *)"delete_CurrencyRatio", _wrap_delete_CurrencyRatio, METH_VARARGS, NULL},
	 { (char *)"CurrencyRatio_swigregister", CurrencyRatio_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefreshQty", _wrap_new_RefreshQty, METH_VARARGS, NULL},
	 { (char *)"delete_RefreshQty", _wrap_delete_RefreshQty, METH_VARARGS, NULL},
	 { (char *)"RefreshQty_swigregister", RefreshQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeRequestStatus", _wrap_new_TradeRequestStatus, METH_VARARGS, NULL},
	 { (char *)"delete_TradeRequestStatus", _wrap_delete_TradeRequestStatus, METH_VARARGS, NULL},
	 { (char *)"TradeRequestStatus_swigregister", TradeRequestStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TrdRepIndicator", _wrap_new_TrdRepIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_TrdRepIndicator", _wrap_delete_TrdRepIndicator, METH_VARARGS, NULL},
	 { (char *)"TrdRepIndicator_swigregister", TrdRepIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MiscFeeAmt", _wrap_new_MiscFeeAmt, METH_VARARGS, NULL},
	 { (char *)"delete_MiscFeeAmt", _wrap_delete_MiscFeeAmt, METH_VARARGS, NULL},
	 { (char *)"MiscFeeAmt_swigregister", MiscFeeAmt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradSesOpenTime", _wrap_new_TradSesOpenTime, METH_VARARGS, NULL},
	 { (char *)"delete_TradSesOpenTime", _wrap_delete_TradSesOpenTime, METH_VARARGS, NULL},
	 { (char *)"TradSesOpenTime_swigregister", TradSesOpenTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PreallocMethod", _wrap_new_PreallocMethod, METH_VARARGS, NULL},
	 { (char *)"delete_PreallocMethod", _wrap_delete_PreallocMethod, METH_VARARGS, NULL},
	 { (char *)"PreallocMethod_swigregister", PreallocMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TaxAdvantageType", _wrap_new_TaxAdvantageType, METH_VARARGS, NULL},
	 { (char *)"delete_TaxAdvantageType", _wrap_delete_TaxAdvantageType, METH_VARARGS, NULL},
	 { (char *)"TaxAdvantageType_swigregister", TaxAdvantageType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MessageEncoding", _wrap_new_MessageEncoding, METH_VARARGS, NULL},
	 { (char *)"delete_MessageEncoding", _wrap_delete_MessageEncoding, METH_VARARGS, NULL},
	 { (char *)"MessageEncoding_swigregister", MessageEncoding_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoPartySubIDs", _wrap_new_NoPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoPartySubIDs", _wrap_delete_NoPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"NoPartySubIDs_swigregister", NoPartySubIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlInstReqID", _wrap_new_SettlInstReqID, METH_VARARGS, NULL},
	 { (char *)"delete_SettlInstReqID", _wrap_delete_SettlInstReqID, METH_VARARGS, NULL},
	 { (char *)"SettlInstReqID_swigregister", SettlInstReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegRepoCollateralSecurityType", _wrap_new_LegRepoCollateralSecurityType, METH_VARARGS, NULL},
	 { (char *)"delete_LegRepoCollateralSecurityType", _wrap_delete_LegRepoCollateralSecurityType, METH_VARARGS, NULL},
	 { (char *)"LegRepoCollateralSecurityType_swigregister", LegRepoCollateralSecurityType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AffectedSecondaryOrderID", _wrap_new_AffectedSecondaryOrderID, METH_VARARGS, NULL},
	 { (char *)"delete_AffectedSecondaryOrderID", _wrap_delete_AffectedSecondaryOrderID, METH_VARARGS, NULL},
	 { (char *)"AffectedSecondaryOrderID_swigregister", AffectedSecondaryOrderID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeMaturityTime", _wrap_new_DerivativeMaturityTime, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeMaturityTime", _wrap_delete_DerivativeMaturityTime, METH_VARARGS, NULL},
	 { (char *)"DerivativeMaturityTime_swigregister", DerivativeMaturityTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExpireTime", _wrap_new_ExpireTime, METH_VARARGS, NULL},
	 { (char *)"delete_ExpireTime", _wrap_delete_ExpireTime, METH_VARARGS, NULL},
	 { (char *)"ExpireTime_swigregister", ExpireTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingFactor", _wrap_new_UnderlyingFactor, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingFactor", _wrap_delete_UnderlyingFactor, METH_VARARGS, NULL},
	 { (char *)"UnderlyingFactor_swigregister", UnderlyingFactor_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrigOrdModTime", _wrap_new_OrigOrdModTime, METH_VARARGS, NULL},
	 { (char *)"delete_OrigOrdModTime", _wrap_delete_OrigOrdModTime, METH_VARARGS, NULL},
	 { (char *)"OrigOrdModTime_swigregister", OrigOrdModTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoTrdRepIndicators", _wrap_new_NoTrdRepIndicators, METH_VARARGS, NULL},
	 { (char *)"delete_NoTrdRepIndicators", _wrap_delete_NoTrdRepIndicators, METH_VARARGS, NULL},
	 { (char *)"NoTrdRepIndicators_swigregister", NoTrdRepIndicators_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeMaturityDate", _wrap_new_DerivativeMaturityDate, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeMaturityDate", _wrap_delete_DerivativeMaturityDate, METH_VARARGS, NULL},
	 { (char *)"DerivativeMaturityDate_swigregister", DerivativeMaturityDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeCFICode", _wrap_new_DerivativeCFICode, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeCFICode", _wrap_delete_DerivativeCFICode, METH_VARARGS, NULL},
	 { (char *)"DerivativeCFICode_swigregister", DerivativeCFICode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested2PartySubIDType", _wrap_new_Nested2PartySubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_Nested2PartySubIDType", _wrap_delete_Nested2PartySubIDType, METH_VARARGS, NULL},
	 { (char *)"Nested2PartySubIDType_swigregister", Nested2PartySubIDType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegIOIQty", _wrap_new_LegIOIQty, METH_VARARGS, NULL},
	 { (char *)"delete_LegIOIQty", _wrap_delete_LegIOIQty, METH_VARARGS, NULL},
	 { (char *)"LegIOIQty_swigregister", LegIOIQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExpireDate", _wrap_new_ExpireDate, METH_VARARGS, NULL},
	 { (char *)"delete_ExpireDate", _wrap_delete_ExpireDate, METH_VARARGS, NULL},
	 { (char *)"ExpireDate_swigregister", ExpireDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoMatchRules", _wrap_new_NoMatchRules, METH_VARARGS, NULL},
	 { (char *)"delete_NoMatchRules", _wrap_delete_NoMatchRules, METH_VARARGS, NULL},
	 { (char *)"NoMatchRules_swigregister", NoMatchRules_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplEndSeqNum", _wrap_new_ApplEndSeqNum, METH_VARARGS, NULL},
	 { (char *)"delete_ApplEndSeqNum", _wrap_delete_ApplEndSeqNum, METH_VARARGS, NULL},
	 { (char *)"ApplEndSeqNum_swigregister", ApplEndSeqNum_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EventPx", _wrap_new_EventPx, METH_VARARGS, NULL},
	 { (char *)"delete_EventPx", _wrap_delete_EventPx, METH_VARARGS, NULL},
	 { (char *)"EventPx_swigregister", EventPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AsgnRptID", _wrap_new_AsgnRptID, METH_VARARGS, NULL},
	 { (char *)"delete_AsgnRptID", _wrap_delete_AsgnRptID, METH_VARARGS, NULL},
	 { (char *)"AsgnRptID_swigregister", AsgnRptID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TimeInForce", _wrap_new_TimeInForce, METH_VARARGS, NULL},
	 { (char *)"delete_TimeInForce", _wrap_delete_TimeInForce, METH_VARARGS, NULL},
	 { (char *)"TimeInForce_swigregister", TimeInForce_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LowPx", _wrap_new_LowPx, METH_VARARGS, NULL},
	 { (char *)"delete_LowPx", _wrap_delete_LowPx, METH_VARARGS, NULL},
	 { (char *)"LowPx_swigregister", LowPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IOIQualifier", _wrap_new_IOIQualifier, METH_VARARGS, NULL},
	 { (char *)"delete_IOIQualifier", _wrap_delete_IOIQualifier, METH_VARARGS, NULL},
	 { (char *)"IOIQualifier_swigregister", IOIQualifier_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_WaveNo", _wrap_new_WaveNo, METH_VARARGS, NULL},
	 { (char *)"delete_WaveNo", _wrap_delete_WaveNo, METH_VARARGS, NULL},
	 { (char *)"WaveNo_swigregister", WaveNo_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StrikePriceBoundaryMethod", _wrap_new_StrikePriceBoundaryMethod, METH_VARARGS, NULL},
	 { (char *)"delete_StrikePriceBoundaryMethod", _wrap_delete_StrikePriceBoundaryMethod, METH_VARARGS, NULL},
	 { (char *)"StrikePriceBoundaryMethod_swigregister", StrikePriceBoundaryMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeIssueDate", _wrap_new_DerivativeIssueDate, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeIssueDate", _wrap_delete_DerivativeIssueDate, METH_VARARGS, NULL},
	 { (char *)"DerivativeIssueDate_swigregister", DerivativeIssueDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MiscFeeType", _wrap_new_MiscFeeType, METH_VARARGS, NULL},
	 { (char *)"delete_MiscFeeType", _wrap_delete_MiscFeeType, METH_VARARGS, NULL},
	 { (char *)"MiscFeeType_swigregister", MiscFeeType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteID", _wrap_new_QuoteID, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteID", _wrap_delete_QuoteID, METH_VARARGS, NULL},
	 { (char *)"QuoteID_swigregister", QuoteID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeInstrumentPartyIDSource", _wrap_new_DerivativeInstrumentPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeInstrumentPartyIDSource", _wrap_delete_DerivativeInstrumentPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"DerivativeInstrumentPartyIDSource_swigregister", DerivativeInstrumentPartyIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlObligID", _wrap_new_SettlObligID, METH_VARARGS, NULL},
	 { (char *)"delete_SettlObligID", _wrap_delete_SettlObligID, METH_VARARGS, NULL},
	 { (char *)"SettlObligID_swigregister", SettlObligID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InstrAttribValue", _wrap_new_InstrAttribValue, METH_VARARGS, NULL},
	 { (char *)"delete_InstrAttribValue", _wrap_delete_InstrAttribValue, METH_VARARGS, NULL},
	 { (char *)"InstrAttribValue_swigregister", InstrAttribValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LiquidityValue", _wrap_new_LiquidityValue, METH_VARARGS, NULL},
	 { (char *)"delete_LiquidityValue", _wrap_delete_LiquidityValue, METH_VARARGS, NULL},
	 { (char *)"LiquidityValue_swigregister", LiquidityValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityIDSource", _wrap_new_SecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityIDSource", _wrap_delete_SecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"SecurityIDSource_swigregister", SecurityIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NewsRefType", _wrap_new_NewsRefType, METH_VARARGS, NULL},
	 { (char *)"delete_NewsRefType", _wrap_delete_NewsRefType, METH_VARARGS, NULL},
	 { (char *)"NewsRefType_swigregister", NewsRefType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoOfLegUnderlyings", _wrap_new_NoOfLegUnderlyings, METH_VARARGS, NULL},
	 { (char *)"delete_NoOfLegUnderlyings", _wrap_delete_NoOfLegUnderlyings, METH_VARARGS, NULL},
	 { (char *)"NoOfLegUnderlyings_swigregister", NoOfLegUnderlyings_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeEncodedSecurityDesc", _wrap_new_DerivativeEncodedSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeEncodedSecurityDesc", _wrap_delete_DerivativeEncodedSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"DerivativeEncodedSecurityDesc_swigregister", DerivativeEncodedSecurityDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerOrderType", _wrap_new_TriggerOrderType, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerOrderType", _wrap_delete_TriggerOrderType, METH_VARARGS, NULL},
	 { (char *)"TriggerOrderType_swigregister", TriggerOrderType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingDirtyPrice", _wrap_new_UnderlyingDirtyPrice, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingDirtyPrice", _wrap_delete_UnderlyingDirtyPrice, METH_VARARGS, NULL},
	 { (char *)"UnderlyingDirtyPrice_swigregister", UnderlyingDirtyPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CrossType", _wrap_new_CrossType, METH_VARARGS, NULL},
	 { (char *)"delete_CrossType", _wrap_delete_CrossType, METH_VARARGS, NULL},
	 { (char *)"CrossType_swigregister", CrossType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RepoCollateralSecurityType", _wrap_new_RepoCollateralSecurityType, METH_VARARGS, NULL},
	 { (char *)"delete_RepoCollateralSecurityType", _wrap_delete_RepoCollateralSecurityType, METH_VARARGS, NULL},
	 { (char *)"RepoCollateralSecurityType_swigregister", RepoCollateralSecurityType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Password", _wrap_new_Password, METH_VARARGS, NULL},
	 { (char *)"delete_Password", _wrap_delete_Password, METH_VARARGS, NULL},
	 { (char *)"Password_swigregister", Password_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OpenCloseSettleFlag", _wrap_new_OpenCloseSettleFlag, METH_VARARGS, NULL},
	 { (char *)"delete_OpenCloseSettleFlag", _wrap_delete_OpenCloseSettleFlag, METH_VARARGS, NULL},
	 { (char *)"OpenCloseSettleFlag_swigregister", OpenCloseSettleFlag_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Subject", _wrap_new_Subject, METH_VARARGS, NULL},
	 { (char *)"delete_Subject", _wrap_delete_Subject, METH_VARARGS, NULL},
	 { (char *)"Subject_swigregister", Subject_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefApplReqID", _wrap_new_RefApplReqID, METH_VARARGS, NULL},
	 { (char *)"delete_RefApplReqID", _wrap_delete_RefApplReqID, METH_VARARGS, NULL},
	 { (char *)"RefApplReqID_swigregister", RefApplReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingEndValue", _wrap_new_UnderlyingEndValue, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingEndValue", _wrap_delete_UnderlyingEndValue, METH_VARARGS, NULL},
	 { (char *)"UnderlyingEndValue_swigregister", UnderlyingEndValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NewSeqNo", _wrap_new_NewSeqNo, METH_VARARGS, NULL},
	 { (char *)"delete_NewSeqNo", _wrap_delete_NewSeqNo, METH_VARARGS, NULL},
	 { (char *)"NewSeqNo_swigregister", NewSeqNo_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrigTradeHandlingInstr", _wrap_new_OrigTradeHandlingInstr, METH_VARARGS, NULL},
	 { (char *)"delete_OrigTradeHandlingInstr", _wrap_delete_OrigTradeHandlingInstr, METH_VARARGS, NULL},
	 { (char *)"OrigTradeHandlingInstr_swigregister", OrigTradeHandlingInstr_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DisplayHighQty", _wrap_new_DisplayHighQty, METH_VARARGS, NULL},
	 { (char *)"delete_DisplayHighQty", _wrap_delete_DisplayHighQty, METH_VARARGS, NULL},
	 { (char *)"DisplayHighQty_swigregister", DisplayHighQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDBookType", _wrap_new_MDBookType, METH_VARARGS, NULL},
	 { (char *)"delete_MDBookType", _wrap_delete_MDBookType, METH_VARARGS, NULL},
	 { (char *)"MDBookType_swigregister", MDBookType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MarginExcess", _wrap_new_MarginExcess, METH_VARARGS, NULL},
	 { (char *)"delete_MarginExcess", _wrap_delete_MarginExcess, METH_VARARGS, NULL},
	 { (char *)"MarginExcess_swigregister", MarginExcess_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BasisPxType", _wrap_new_BasisPxType, METH_VARARGS, NULL},
	 { (char *)"delete_BasisPxType", _wrap_delete_BasisPxType, METH_VARARGS, NULL},
	 { (char *)"BasisPxType_swigregister", BasisPxType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DlvyInst", _wrap_new_DlvyInst, METH_VARARGS, NULL},
	 { (char *)"delete_DlvyInst", _wrap_delete_DlvyInst, METH_VARARGS, NULL},
	 { (char *)"DlvyInst_swigregister", DlvyInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ComplianceID", _wrap_new_ComplianceID, METH_VARARGS, NULL},
	 { (char *)"delete_ComplianceID", _wrap_delete_ComplianceID, METH_VARARGS, NULL},
	 { (char *)"ComplianceID_swigregister", ComplianceID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EmailThreadID", _wrap_new_EmailThreadID, METH_VARARGS, NULL},
	 { (char *)"delete_EmailThreadID", _wrap_delete_EmailThreadID, METH_VARARGS, NULL},
	 { (char *)"EmailThreadID_swigregister", EmailThreadID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ContAmtCurr", _wrap_new_ContAmtCurr, METH_VARARGS, NULL},
	 { (char *)"delete_ContAmtCurr", _wrap_delete_ContAmtCurr, METH_VARARGS, NULL},
	 { (char *)"ContAmtCurr_swigregister", ContAmtCurr_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ComplexEventType", _wrap_new_ComplexEventType, METH_VARARGS, NULL},
	 { (char *)"delete_ComplexEventType", _wrap_delete_ComplexEventType, METH_VARARGS, NULL},
	 { (char *)"ComplexEventType_swigregister", ComplexEventType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MassActionResponse", _wrap_new_MassActionResponse, METH_VARARGS, NULL},
	 { (char *)"delete_MassActionResponse", _wrap_delete_MassActionResponse, METH_VARARGS, NULL},
	 { (char *)"MassActionResponse_swigregister", MassActionResponse_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingIssueDate", _wrap_new_UnderlyingIssueDate, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingIssueDate", _wrap_delete_UnderlyingIssueDate, METH_VARARGS, NULL},
	 { (char *)"UnderlyingIssueDate_swigregister", UnderlyingIssueDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityRequestType", _wrap_new_SecurityRequestType, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityRequestType", _wrap_delete_SecurityRequestType, METH_VARARGS, NULL},
	 { (char *)"SecurityRequestType_swigregister", SecurityRequestType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocInterestAtMaturity", _wrap_new_AllocInterestAtMaturity, METH_VARARGS, NULL},
	 { (char *)"delete_AllocInterestAtMaturity", _wrap_delete_AllocInterestAtMaturity, METH_VARARGS, NULL},
	 { (char *)"AllocInterestAtMaturity_swigregister", AllocInterestAtMaturity_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ListRejectReason", _wrap_new_ListRejectReason, METH_VARARGS, NULL},
	 { (char *)"delete_ListRejectReason", _wrap_delete_ListRejectReason, METH_VARARGS, NULL},
	 { (char *)"ListRejectReason_swigregister", ListRejectReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DeskType", _wrap_new_DeskType, METH_VARARGS, NULL},
	 { (char *)"delete_DeskType", _wrap_delete_DeskType, METH_VARARGS, NULL},
	 { (char *)"DeskType_swigregister", DeskType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryTradeReportID", _wrap_new_SecondaryTradeReportID, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryTradeReportID", _wrap_delete_SecondaryTradeReportID, METH_VARARGS, NULL},
	 { (char *)"SecondaryTradeReportID_swigregister", SecondaryTradeReportID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlType", _wrap_new_SettlType, METH_VARARGS, NULL},
	 { (char *)"delete_SettlType", _wrap_delete_SettlType, METH_VARARGS, NULL},
	 { (char *)"SettlType_swigregister", SettlType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OpenClose", _wrap_new_OpenClose, METH_VARARGS, NULL},
	 { (char *)"delete_OpenClose", _wrap_delete_OpenClose, METH_VARARGS, NULL},
	 { (char *)"OpenClose_swigregister", OpenClose_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ContractMultiplierUnit", _wrap_new_ContractMultiplierUnit, METH_VARARGS, NULL},
	 { (char *)"delete_ContractMultiplierUnit", _wrap_delete_ContractMultiplierUnit, METH_VARARGS, NULL},
	 { (char *)"ContractMultiplierUnit_swigregister", ContractMultiplierUnit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryLowLimitPrice", _wrap_new_SecondaryLowLimitPrice, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryLowLimitPrice", _wrap_delete_SecondaryLowLimitPrice, METH_VARARGS, NULL},
	 { (char *)"SecondaryLowLimitPrice_swigregister", SecondaryLowLimitPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExpQty", _wrap_new_ExpQty, METH_VARARGS, NULL},
	 { (char *)"delete_ExpQty", _wrap_delete_ExpQty, METH_VARARGS, NULL},
	 { (char *)"ExpQty_swigregister", ExpQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NetworkRequestID", _wrap_new_NetworkRequestID, METH_VARARGS, NULL},
	 { (char *)"delete_NetworkRequestID", _wrap_delete_NetworkRequestID, METH_VARARGS, NULL},
	 { (char *)"NetworkRequestID_swigregister", NetworkRequestID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TrdType", _wrap_new_TrdType, METH_VARARGS, NULL},
	 { (char *)"delete_TrdType", _wrap_delete_TrdType, METH_VARARGS, NULL},
	 { (char *)"TrdType_swigregister", TrdType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoUnderlyings", _wrap_new_NoUnderlyings, METH_VARARGS, NULL},
	 { (char *)"delete_NoUnderlyings", _wrap_delete_NoUnderlyings, METH_VARARGS, NULL},
	 { (char *)"NoUnderlyings_swigregister", NoUnderlyings_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDMkt", _wrap_new_MDMkt, METH_VARARGS, NULL},
	 { (char *)"delete_MDMkt", _wrap_delete_MDMkt, METH_VARARGS, NULL},
	 { (char *)"MDMkt_swigregister", MDMkt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastMkt", _wrap_new_LastMkt, METH_VARARGS, NULL},
	 { (char *)"delete_LastMkt", _wrap_delete_LastMkt, METH_VARARGS, NULL},
	 { (char *)"LastMkt_swigregister", LastMkt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RestructuringType", _wrap_new_RestructuringType, METH_VARARGS, NULL},
	 { (char *)"delete_RestructuringType", _wrap_delete_RestructuringType, METH_VARARGS, NULL},
	 { (char *)"RestructuringType_swigregister", RestructuringType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoStrikeRules", _wrap_new_NoStrikeRules, METH_VARARGS, NULL},
	 { (char *)"delete_NoStrikeRules", _wrap_delete_NoStrikeRules, METH_VARARGS, NULL},
	 { (char *)"NoStrikeRules_swigregister", NoStrikeRules_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ListName", _wrap_new_ListName, METH_VARARGS, NULL},
	 { (char *)"delete_ListName", _wrap_delete_ListName, METH_VARARGS, NULL},
	 { (char *)"ListName_swigregister", ListName_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ProgRptReqs", _wrap_new_ProgRptReqs, METH_VARARGS, NULL},
	 { (char *)"delete_ProgRptReqs", _wrap_delete_ProgRptReqs, METH_VARARGS, NULL},
	 { (char *)"ProgRptReqs_swigregister", ProgRptReqs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradingSessionID", _wrap_new_TradingSessionID, METH_VARARGS, NULL},
	 { (char *)"delete_TradingSessionID", _wrap_delete_TradingSessionID, METH_VARARGS, NULL},
	 { (char *)"TradingSessionID_swigregister", TradingSessionID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ListOrderStatus", _wrap_new_ListOrderStatus, METH_VARARGS, NULL},
	 { (char *)"delete_ListOrderStatus", _wrap_delete_ListOrderStatus, METH_VARARGS, NULL},
	 { (char *)"ListOrderStatus_swigregister", ListOrderStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RegistStatus", _wrap_new_RegistStatus, METH_VARARGS, NULL},
	 { (char *)"delete_RegistStatus", _wrap_delete_RegistStatus, METH_VARARGS, NULL},
	 { (char *)"RegistStatus_swigregister", RegistStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PosAmt", _wrap_new_PosAmt, METH_VARARGS, NULL},
	 { (char *)"delete_PosAmt", _wrap_delete_PosAmt, METH_VARARGS, NULL},
	 { (char *)"PosAmt_swigregister", PosAmt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingPriceDeterminationMethod", _wrap_new_UnderlyingPriceDeterminationMethod, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingPriceDeterminationMethod", _wrap_delete_UnderlyingPriceDeterminationMethod, METH_VARARGS, NULL},
	 { (char *)"UnderlyingPriceDeterminationMethod_swigregister", UnderlyingPriceDeterminationMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoUnderlyingStips", _wrap_new_NoUnderlyingStips, METH_VARARGS, NULL},
	 { (char *)"delete_NoUnderlyingStips", _wrap_delete_NoUnderlyingStips, METH_VARARGS, NULL},
	 { (char *)"NoUnderlyingStips_swigregister", NoUnderlyingStips_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradSesPreCloseTime", _wrap_new_TradSesPreCloseTime, METH_VARARGS, NULL},
	 { (char *)"delete_TradSesPreCloseTime", _wrap_delete_TradSesPreCloseTime, METH_VARARGS, NULL},
	 { (char *)"TradSesPreCloseTime_swigregister", TradSesPreCloseTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MassCancelRequestType", _wrap_new_MassCancelRequestType, METH_VARARGS, NULL},
	 { (char *)"delete_MassCancelRequestType", _wrap_delete_MassCancelRequestType, METH_VARARGS, NULL},
	 { (char *)"MassCancelRequestType_swigregister", MassCancelRequestType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegSecurityAltIDSource", _wrap_new_UnderlyingLegSecurityAltIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegSecurityAltIDSource", _wrap_delete_UnderlyingLegSecurityAltIDSource, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegSecurityAltIDSource_swigregister", UnderlyingLegSecurityAltIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlPartyID", _wrap_new_SettlPartyID, METH_VARARGS, NULL},
	 { (char *)"delete_SettlPartyID", _wrap_delete_SettlPartyID, METH_VARARGS, NULL},
	 { (char *)"SettlPartyID_swigregister", SettlPartyID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoAffectedOrders", _wrap_new_NoAffectedOrders, METH_VARARGS, NULL},
	 { (char *)"delete_NoAffectedOrders", _wrap_delete_NoAffectedOrders, METH_VARARGS, NULL},
	 { (char *)"NoAffectedOrders_swigregister", NoAffectedOrders_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashSettlAgentAcctNum", _wrap_new_CashSettlAgentAcctNum, METH_VARARGS, NULL},
	 { (char *)"delete_CashSettlAgentAcctNum", _wrap_delete_CashSettlAgentAcctNum, METH_VARARGS, NULL},
	 { (char *)"CashSettlAgentAcctNum_swigregister", CashSettlAgentAcctNum_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegMaturityMonthYear", _wrap_new_UnderlyingLegMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegMaturityMonthYear", _wrap_delete_UnderlyingLegMaturityMonthYear, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegMaturityMonthYear_swigregister", UnderlyingLegMaturityMonthYear_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoLotTypeRules", _wrap_new_NoLotTypeRules, METH_VARARGS, NULL},
	 { (char *)"delete_NoLotTypeRules", _wrap_delete_NoLotTypeRules, METH_VARARGS, NULL},
	 { (char *)"NoLotTypeRules_swigregister", NoLotTypeRules_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoDates", _wrap_new_NoDates, METH_VARARGS, NULL},
	 { (char *)"delete_NoDates", _wrap_delete_NoDates, METH_VARARGS, NULL},
	 { (char *)"NoDates_swigregister", NoDates_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CxlRejResponseTo", _wrap_new_CxlRejResponseTo, METH_VARARGS, NULL},
	 { (char *)"delete_CxlRejResponseTo", _wrap_delete_CxlRejResponseTo, METH_VARARGS, NULL},
	 { (char *)"CxlRejResponseTo_swigregister", CxlRejResponseTo_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EffectiveTime", _wrap_new_EffectiveTime, METH_VARARGS, NULL},
	 { (char *)"delete_EffectiveTime", _wrap_delete_EffectiveTime, METH_VARARGS, NULL},
	 { (char *)"EffectiveTime_swigregister", EffectiveTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_GrossTradeAmt", _wrap_new_GrossTradeAmt, METH_VARARGS, NULL},
	 { (char *)"delete_GrossTradeAmt", _wrap_delete_GrossTradeAmt, METH_VARARGS, NULL},
	 { (char *)"GrossTradeAmt_swigregister", GrossTradeAmt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityListDesc", _wrap_new_SecurityListDesc, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityListDesc", _wrap_delete_SecurityListDesc, METH_VARARGS, NULL},
	 { (char *)"SecurityListDesc_swigregister", SecurityListDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NotAffectedOrderID", _wrap_new_NotAffectedOrderID, METH_VARARGS, NULL},
	 { (char *)"delete_NotAffectedOrderID", _wrap_delete_NotAffectedOrderID, METH_VARARGS, NULL},
	 { (char *)"NotAffectedOrderID_swigregister", NotAffectedOrderID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeStrikeValue", _wrap_new_DerivativeStrikeValue, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeStrikeValue", _wrap_delete_DerivativeStrikeValue, METH_VARARGS, NULL},
	 { (char *)"DerivativeStrikeValue_swigregister", DerivativeStrikeValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoPosAmt", _wrap_new_NoPosAmt, METH_VARARGS, NULL},
	 { (char *)"delete_NoPosAmt", _wrap_delete_NoPosAmt, METH_VARARGS, NULL},
	 { (char *)"NoPosAmt_swigregister", NoPosAmt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegCreditRating", _wrap_new_LegCreditRating, METH_VARARGS, NULL},
	 { (char *)"delete_LegCreditRating", _wrap_delete_LegCreditRating, METH_VARARGS, NULL},
	 { (char *)"LegCreditRating_swigregister", LegCreditRating_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BidForwardPoints2", _wrap_new_BidForwardPoints2, METH_VARARGS, NULL},
	 { (char *)"delete_BidForwardPoints2", _wrap_delete_BidForwardPoints2, METH_VARARGS, NULL},
	 { (char *)"BidForwardPoints2_swigregister", BidForwardPoints2_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlDate", _wrap_new_SettlDate, METH_VARARGS, NULL},
	 { (char *)"delete_SettlDate", _wrap_delete_SettlDate, METH_VARARGS, NULL},
	 { (char *)"SettlDate_swigregister", SettlDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ClientID", _wrap_new_ClientID, METH_VARARGS, NULL},
	 { (char *)"delete_ClientID", _wrap_delete_ClientID, METH_VARARGS, NULL},
	 { (char *)"ClientID_swigregister", ClientID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteCancelType", _wrap_new_QuoteCancelType, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteCancelType", _wrap_delete_QuoteCancelType, METH_VARARGS, NULL},
	 { (char *)"QuoteCancelType_swigregister", QuoteCancelType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StipulationType", _wrap_new_StipulationType, METH_VARARGS, NULL},
	 { (char *)"delete_StipulationType", _wrap_delete_StipulationType, METH_VARARGS, NULL},
	 { (char *)"StipulationType_swigregister", StipulationType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OutMainCntryUIndex", _wrap_new_OutMainCntryUIndex, METH_VARARGS, NULL},
	 { (char *)"delete_OutMainCntryUIndex", _wrap_delete_OutMainCntryUIndex, METH_VARARGS, NULL},
	 { (char *)"OutMainCntryUIndex_swigregister", OutMainCntryUIndex_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSettlmntTyp", _wrap_new_LegSettlmntTyp, METH_VARARGS, NULL},
	 { (char *)"delete_LegSettlmntTyp", _wrap_delete_LegSettlmntTyp, METH_VARARGS, NULL},
	 { (char *)"LegSettlmntTyp_swigregister", LegSettlmntTyp_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeNTPositionLimit", _wrap_new_DerivativeNTPositionLimit, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeNTPositionLimit", _wrap_delete_DerivativeNTPositionLimit, METH_VARARGS, NULL},
	 { (char *)"DerivativeNTPositionLimit_swigregister", DerivativeNTPositionLimit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PriceQuoteMethod", _wrap_new_PriceQuoteMethod, METH_VARARGS, NULL},
	 { (char *)"delete_PriceQuoteMethod", _wrap_delete_PriceQuoteMethod, METH_VARARGS, NULL},
	 { (char *)"PriceQuoteMethod_swigregister", PriceQuoteMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LowLimitPrice", _wrap_new_LowLimitPrice, METH_VARARGS, NULL},
	 { (char *)"delete_LowLimitPrice", _wrap_delete_LowLimitPrice, METH_VARARGS, NULL},
	 { (char *)"LowLimitPrice_swigregister", LowLimitPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegUnitOfMeasure", _wrap_new_LegUnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"delete_LegUnitOfMeasure", _wrap_delete_LegUnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"LegUnitOfMeasure_swigregister", LegUnitOfMeasure_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SessionRejectReason", _wrap_new_SessionRejectReason, METH_VARARGS, NULL},
	 { (char *)"delete_SessionRejectReason", _wrap_delete_SessionRejectReason, METH_VARARGS, NULL},
	 { (char *)"SessionRejectReason_swigregister", SessionRejectReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DeliveryType", _wrap_new_DeliveryType, METH_VARARGS, NULL},
	 { (char *)"delete_DeliveryType", _wrap_delete_DeliveryType, METH_VARARGS, NULL},
	 { (char *)"DeliveryType_swigregister", DeliveryType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocPrice", _wrap_new_AllocPrice, METH_VARARGS, NULL},
	 { (char *)"delete_AllocPrice", _wrap_delete_AllocPrice, METH_VARARGS, NULL},
	 { (char *)"AllocPrice_swigregister", AllocPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoBidComponents", _wrap_new_NoBidComponents, METH_VARARGS, NULL},
	 { (char *)"delete_NoBidComponents", _wrap_delete_NoBidComponents, METH_VARARGS, NULL},
	 { (char *)"NoBidComponents_swigregister", NoBidComponents_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteQualifier", _wrap_new_QuoteQualifier, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteQualifier", _wrap_delete_QuoteQualifier, METH_VARARGS, NULL},
	 { (char *)"QuoteQualifier_swigregister", QuoteQualifier_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Scope", _wrap_new_Scope, METH_VARARGS, NULL},
	 { (char *)"delete_Scope", _wrap_delete_Scope, METH_VARARGS, NULL},
	 { (char *)"Scope_swigregister", Scope_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoSecurityAltID", _wrap_new_NoSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"delete_NoSecurityAltID", _wrap_delete_NoSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"NoSecurityAltID_swigregister", NoSecurityAltID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RootPartySubID", _wrap_new_RootPartySubID, METH_VARARGS, NULL},
	 { (char *)"delete_RootPartySubID", _wrap_delete_RootPartySubID, METH_VARARGS, NULL},
	 { (char *)"RootPartySubID_swigregister", RootPartySubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DeliverToLocationID", _wrap_new_DeliverToLocationID, METH_VARARGS, NULL},
	 { (char *)"delete_DeliverToLocationID", _wrap_delete_DeliverToLocationID, METH_VARARGS, NULL},
	 { (char *)"DeliverToLocationID_swigregister", DeliverToLocationID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DeleteReason", _wrap_new_DeleteReason, METH_VARARGS, NULL},
	 { (char *)"delete_DeleteReason", _wrap_delete_DeleteReason, METH_VARARGS, NULL},
	 { (char *)"DeleteReason_swigregister", DeleteReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BidSpotRate", _wrap_new_BidSpotRate, METH_VARARGS, NULL},
	 { (char *)"delete_BidSpotRate", _wrap_delete_BidSpotRate, METH_VARARGS, NULL},
	 { (char *)"BidSpotRate_swigregister", BidSpotRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested4PartyID", _wrap_new_Nested4PartyID, METH_VARARGS, NULL},
	 { (char *)"delete_Nested4PartyID", _wrap_delete_Nested4PartyID, METH_VARARGS, NULL},
	 { (char *)"Nested4PartyID_swigregister", Nested4PartyID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InViewOfCommon", _wrap_new_InViewOfCommon, METH_VARARGS, NULL},
	 { (char *)"delete_InViewOfCommon", _wrap_delete_InViewOfCommon, METH_VARARGS, NULL},
	 { (char *)"InViewOfCommon_swigregister", InViewOfCommon_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSettlPrice", _wrap_new_UnderlyingSettlPrice, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSettlPrice", _wrap_delete_UnderlyingSettlPrice, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSettlPrice_swigregister", UnderlyingSettlPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RegistRejReasonText", _wrap_new_RegistRejReasonText, METH_VARARGS, NULL},
	 { (char *)"delete_RegistRejReasonText", _wrap_delete_RegistRejReasonText, METH_VARARGS, NULL},
	 { (char *)"RegistRejReasonText_swigregister", RegistRejReasonText_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoSides", _wrap_new_NoSides, METH_VARARGS, NULL},
	 { (char *)"delete_NoSides", _wrap_delete_NoSides, METH_VARARGS, NULL},
	 { (char *)"NoSides_swigregister", NoSides_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegAllocAccount", _wrap_new_LegAllocAccount, METH_VARARGS, NULL},
	 { (char *)"delete_LegAllocAccount", _wrap_delete_LegAllocAccount, METH_VARARGS, NULL},
	 { (char *)"LegAllocAccount_swigregister", LegAllocAccount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSecurityDesc", _wrap_new_LegSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"delete_LegSecurityDesc", _wrap_delete_LegSecurityDesc, METH_VARARGS, NULL},
	 { (char *)"LegSecurityDesc_swigregister", LegSecurityDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ClOrdLinkID", _wrap_new_ClOrdLinkID, METH_VARARGS, NULL},
	 { (char *)"delete_ClOrdLinkID", _wrap_delete_ClOrdLinkID, METH_VARARGS, NULL},
	 { (char *)"ClOrdLinkID_swigregister", ClOrdLinkID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrigSendingTime", _wrap_new_OrigSendingTime, METH_VARARGS, NULL},
	 { (char *)"delete_OrigSendingTime", _wrap_delete_OrigSendingTime, METH_VARARGS, NULL},
	 { (char *)"OrigSendingTime_swigregister", OrigSendingTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedLegIssuerLen", _wrap_new_EncodedLegIssuerLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedLegIssuerLen", _wrap_delete_EncodedLegIssuerLen, METH_VARARGS, NULL},
	 { (char *)"EncodedLegIssuerLen_swigregister", EncodedLegIssuerLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrderID", _wrap_new_OrderID, METH_VARARGS, NULL},
	 { (char *)"delete_OrderID", _wrap_delete_OrderID, METH_VARARGS, NULL},
	 { (char *)"OrderID_swigregister", OrderID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityType", _wrap_new_SecurityType, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityType", _wrap_delete_SecurityType, METH_VARARGS, NULL},
	 { (char *)"SecurityType_swigregister", SecurityType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RoundingDirection", _wrap_new_RoundingDirection, METH_VARARGS, NULL},
	 { (char *)"delete_RoundingDirection", _wrap_delete_RoundingDirection, METH_VARARGS, NULL},
	 { (char *)"RoundingDirection_swigregister", RoundingDirection_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FillExecID", _wrap_new_FillExecID, METH_VARARGS, NULL},
	 { (char *)"delete_FillExecID", _wrap_delete_FillExecID, METH_VARARGS, NULL},
	 { (char *)"FillExecID_swigregister", FillExecID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoEvents", _wrap_new_NoEvents, METH_VARARGS, NULL},
	 { (char *)"delete_NoEvents", _wrap_delete_NoEvents, METH_VARARGS, NULL},
	 { (char *)"NoEvents_swigregister", NoEvents_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RoundLot", _wrap_new_RoundLot, METH_VARARGS, NULL},
	 { (char *)"delete_RoundLot", _wrap_delete_RoundLot, METH_VARARGS, NULL},
	 { (char *)"RoundLot_swigregister", RoundLot_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDEntrySize", _wrap_new_MDEntrySize, METH_VARARGS, NULL},
	 { (char *)"delete_MDEntrySize", _wrap_delete_MDEntrySize, METH_VARARGS, NULL},
	 { (char *)"MDEntrySize_swigregister", MDEntrySize_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedIssuerLen", _wrap_new_EncodedIssuerLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedIssuerLen", _wrap_delete_EncodedIssuerLen, METH_VARARGS, NULL},
	 { (char *)"EncodedIssuerLen_swigregister", EncodedIssuerLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativePriceUnitOfMeasureQty", _wrap_new_DerivativePriceUnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativePriceUnitOfMeasureQty", _wrap_delete_DerivativePriceUnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"DerivativePriceUnitOfMeasureQty_swigregister", DerivativePriceUnitOfMeasureQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TimeUnit", _wrap_new_TimeUnit, METH_VARARGS, NULL},
	 { (char *)"delete_TimeUnit", _wrap_delete_TimeUnit, METH_VARARGS, NULL},
	 { (char *)"TimeUnit_swigregister", TimeUnit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotNoOrders", _wrap_new_TotNoOrders, METH_VARARGS, NULL},
	 { (char *)"delete_TotNoOrders", _wrap_delete_TotNoOrders, METH_VARARGS, NULL},
	 { (char *)"TotNoOrders_swigregister", TotNoOrders_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSwapType", _wrap_new_LegSwapType, METH_VARARGS, NULL},
	 { (char *)"delete_LegSwapType", _wrap_delete_LegSwapType, METH_VARARGS, NULL},
	 { (char *)"LegSwapType_swigregister", LegSwapType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IOITransType", _wrap_new_IOITransType, METH_VARARGS, NULL},
	 { (char *)"delete_IOITransType", _wrap_delete_IOITransType, METH_VARARGS, NULL},
	 { (char *)"IOITransType_swigregister", IOITransType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RawDataLength", _wrap_new_RawDataLength, METH_VARARGS, NULL},
	 { (char *)"delete_RawDataLength", _wrap_delete_RawDataLength, METH_VARARGS, NULL},
	 { (char *)"RawDataLength_swigregister", RawDataLength_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSecurityType", _wrap_new_UnderlyingSecurityType, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSecurityType", _wrap_delete_UnderlyingSecurityType, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSecurityType_swigregister", UnderlyingSecurityType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegSecurityAltID", _wrap_new_UnderlyingLegSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegSecurityAltID", _wrap_delete_UnderlyingLegSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegSecurityAltID_swigregister", UnderlyingLegSecurityAltID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityReportID", _wrap_new_SecurityReportID, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityReportID", _wrap_delete_SecurityReportID, METH_VARARGS, NULL},
	 { (char *)"SecurityReportID_swigregister", SecurityReportID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotNumReports", _wrap_new_TotNumReports, METH_VARARGS, NULL},
	 { (char *)"delete_TotNumReports", _wrap_delete_TotNumReports, METH_VARARGS, NULL},
	 { (char *)"TotNumReports_swigregister", TotNumReports_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotalNumPosReports", _wrap_new_TotalNumPosReports, METH_VARARGS, NULL},
	 { (char *)"delete_TotalNumPosReports", _wrap_delete_TotalNumPosReports, METH_VARARGS, NULL},
	 { (char *)"TotalNumPosReports_swigregister", TotalNumPosReports_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityReqID", _wrap_new_SecurityReqID, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityReqID", _wrap_delete_SecurityReqID, METH_VARARGS, NULL},
	 { (char *)"SecurityReqID_swigregister", SecurityReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PosReqResult", _wrap_new_PosReqResult, METH_VARARGS, NULL},
	 { (char *)"delete_PosReqResult", _wrap_delete_PosReqResult, METH_VARARGS, NULL},
	 { (char *)"PosReqResult_swigregister", PosReqResult_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegOfferForwardPoints", _wrap_new_LegOfferForwardPoints, METH_VARARGS, NULL},
	 { (char *)"delete_LegOfferForwardPoints", _wrap_delete_LegOfferForwardPoints, METH_VARARGS, NULL},
	 { (char *)"LegOfferForwardPoints_swigregister", LegOfferForwardPoints_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllowableOneSidednessCurr", _wrap_new_AllowableOneSidednessCurr, METH_VARARGS, NULL},
	 { (char *)"delete_AllowableOneSidednessCurr", _wrap_delete_AllowableOneSidednessCurr, METH_VARARGS, NULL},
	 { (char *)"AllowableOneSidednessCurr_swigregister", AllowableOneSidednessCurr_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AffectedOrderID", _wrap_new_AffectedOrderID, METH_VARARGS, NULL},
	 { (char *)"delete_AffectedOrderID", _wrap_delete_AffectedOrderID, METH_VARARGS, NULL},
	 { (char *)"AffectedOrderID_swigregister", AffectedOrderID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingCountryOfIssue", _wrap_new_UnderlyingCountryOfIssue, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingCountryOfIssue", _wrap_delete_UnderlyingCountryOfIssue, METH_VARARGS, NULL},
	 { (char *)"UnderlyingCountryOfIssue_swigregister", UnderlyingCountryOfIssue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingRepurchaseRate", _wrap_new_UnderlyingRepurchaseRate, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingRepurchaseRate", _wrap_delete_UnderlyingRepurchaseRate, METH_VARARGS, NULL},
	 { (char *)"UnderlyingRepurchaseRate_swigregister", UnderlyingRepurchaseRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastMsgSeqNumProcessed", _wrap_new_LastMsgSeqNumProcessed, METH_VARARGS, NULL},
	 { (char *)"delete_LastMsgSeqNumProcessed", _wrap_delete_LastMsgSeqNumProcessed, METH_VARARGS, NULL},
	 { (char *)"LastMsgSeqNumProcessed_swigregister", LastMsgSeqNumProcessed_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingCFICode", _wrap_new_UnderlyingCFICode, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingCFICode", _wrap_delete_UnderlyingCFICode, METH_VARARGS, NULL},
	 { (char *)"UnderlyingCFICode_swigregister", UnderlyingCFICode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeOptAttribute", _wrap_new_DerivativeOptAttribute, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeOptAttribute", _wrap_delete_DerivativeOptAttribute, METH_VARARGS, NULL},
	 { (char *)"DerivativeOptAttribute_swigregister", DerivativeOptAttribute_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PegSecurityID", _wrap_new_PegSecurityID, METH_VARARGS, NULL},
	 { (char *)"delete_PegSecurityID", _wrap_delete_PegSecurityID, METH_VARARGS, NULL},
	 { (char *)"PegSecurityID_swigregister", PegSecurityID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HostCrossID", _wrap_new_HostCrossID, METH_VARARGS, NULL},
	 { (char *)"delete_HostCrossID", _wrap_delete_HostCrossID, METH_VARARGS, NULL},
	 { (char *)"HostCrossID_swigregister", HostCrossID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExecInstValue", _wrap_new_ExecInstValue, METH_VARARGS, NULL},
	 { (char *)"delete_ExecInstValue", _wrap_delete_ExecInstValue, METH_VARARGS, NULL},
	 { (char *)"ExecInstValue_swigregister", ExecInstValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeOptPayAmount", _wrap_new_DerivativeOptPayAmount, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeOptPayAmount", _wrap_delete_DerivativeOptPayAmount, METH_VARARGS, NULL},
	 { (char *)"DerivativeOptPayAmount_swigregister", DerivativeOptPayAmount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingCouponRate", _wrap_new_UnderlyingCouponRate, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingCouponRate", _wrap_delete_UnderlyingCouponRate, METH_VARARGS, NULL},
	 { (char *)"UnderlyingCouponRate_swigregister", UnderlyingCouponRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlInstMode", _wrap_new_SettlInstMode, METH_VARARGS, NULL},
	 { (char *)"delete_SettlInstMode", _wrap_delete_SettlInstMode, METH_VARARGS, NULL},
	 { (char *)"SettlInstMode_swigregister", SettlInstMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityAltIDSource", _wrap_new_SecurityAltIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityAltIDSource", _wrap_delete_SecurityAltIDSource, METH_VARARGS, NULL},
	 { (char *)"SecurityAltIDSource_swigregister", SecurityAltIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PreviouslyReported", _wrap_new_PreviouslyReported, METH_VARARGS, NULL},
	 { (char *)"delete_PreviouslyReported", _wrap_delete_PreviouslyReported, METH_VARARGS, NULL},
	 { (char *)"PreviouslyReported_swigregister", PreviouslyReported_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RptSys", _wrap_new_RptSys, METH_VARARGS, NULL},
	 { (char *)"delete_RptSys", _wrap_delete_RptSys, METH_VARARGS, NULL},
	 { (char *)"RptSys_swigregister", RptSys_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoNested2PartySubIDs", _wrap_new_NoNested2PartySubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoNested2PartySubIDs", _wrap_delete_NoNested2PartySubIDs, METH_VARARGS, NULL},
	 { (char *)"NoNested2PartySubIDs_swigregister", NoNested2PartySubIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefAllocID", _wrap_new_RefAllocID, METH_VARARGS, NULL},
	 { (char *)"delete_RefAllocID", _wrap_delete_RefAllocID, METH_VARARGS, NULL},
	 { (char *)"RefAllocID_swigregister", RefAllocID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DefOfferSize", _wrap_new_DefOfferSize, METH_VARARGS, NULL},
	 { (char *)"delete_DefOfferSize", _wrap_delete_DefOfferSize, METH_VARARGS, NULL},
	 { (char *)"DefOfferSize_swigregister", DefOfferSize_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ProductComplex", _wrap_new_ProductComplex, METH_VARARGS, NULL},
	 { (char *)"delete_ProductComplex", _wrap_delete_ProductComplex, METH_VARARGS, NULL},
	 { (char *)"ProductComplex_swigregister", ProductComplex_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CustOrderHandlingInst", _wrap_new_CustOrderHandlingInst, METH_VARARGS, NULL},
	 { (char *)"delete_CustOrderHandlingInst", _wrap_delete_CustOrderHandlingInst, METH_VARARGS, NULL},
	 { (char *)"CustOrderHandlingInst_swigregister", CustOrderHandlingInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDPriceLevel", _wrap_new_MDPriceLevel, METH_VARARGS, NULL},
	 { (char *)"delete_MDPriceLevel", _wrap_delete_MDPriceLevel, METH_VARARGS, NULL},
	 { (char *)"MDPriceLevel_swigregister", MDPriceLevel_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegOptionRatio", _wrap_new_LegOptionRatio, METH_VARARGS, NULL},
	 { (char *)"delete_LegOptionRatio", _wrap_delete_LegOptionRatio, METH_VARARGS, NULL},
	 { (char *)"LegOptionRatio_swigregister", LegOptionRatio_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityStatus", _wrap_new_SecurityStatus, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityStatus", _wrap_delete_SecurityStatus, METH_VARARGS, NULL},
	 { (char *)"SecurityStatus_swigregister", SecurityStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegRefID", _wrap_new_LegRefID, METH_VARARGS, NULL},
	 { (char *)"delete_LegRefID", _wrap_delete_LegRefID, METH_VARARGS, NULL},
	 { (char *)"LegRefID_swigregister", LegRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DividendYield", _wrap_new_DividendYield, METH_VARARGS, NULL},
	 { (char *)"delete_DividendYield", _wrap_delete_DividendYield, METH_VARARGS, NULL},
	 { (char *)"DividendYield_swigregister", DividendYield_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeInstrumentPartySubIDType", _wrap_new_DerivativeInstrumentPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeInstrumentPartySubIDType", _wrap_delete_DerivativeInstrumentPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"DerivativeInstrumentPartySubIDType_swigregister", DerivativeInstrumentPartySubIDType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EndStrikePxRange", _wrap_new_EndStrikePxRange, METH_VARARGS, NULL},
	 { (char *)"delete_EndStrikePxRange", _wrap_delete_EndStrikePxRange, METH_VARARGS, NULL},
	 { (char *)"EndStrikePxRange_swigregister", EndStrikePxRange_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DisplayQty", _wrap_new_DisplayQty, METH_VARARGS, NULL},
	 { (char *)"delete_DisplayQty", _wrap_delete_DisplayQty, METH_VARARGS, NULL},
	 { (char *)"DisplayQty_swigregister", DisplayQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSecuritySubType", _wrap_new_LegSecuritySubType, METH_VARARGS, NULL},
	 { (char *)"delete_LegSecuritySubType", _wrap_delete_LegSecuritySubType, METH_VARARGS, NULL},
	 { (char *)"LegSecuritySubType_swigregister", LegSecuritySubType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ProcessCode", _wrap_new_ProcessCode, METH_VARARGS, NULL},
	 { (char *)"delete_ProcessCode", _wrap_delete_ProcessCode, METH_VARARGS, NULL},
	 { (char *)"ProcessCode_swigregister", ProcessCode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExecInst", _wrap_new_ExecInst, METH_VARARGS, NULL},
	 { (char *)"delete_ExecInst", _wrap_delete_ExecInst, METH_VARARGS, NULL},
	 { (char *)"ExecInst_swigregister", ExecInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradSesEndTime", _wrap_new_TradSesEndTime, METH_VARARGS, NULL},
	 { (char *)"delete_TradSesEndTime", _wrap_delete_TradSesEndTime, METH_VARARGS, NULL},
	 { (char *)"TradSesEndTime_swigregister", TradSesEndTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrigTime", _wrap_new_OrigTime, METH_VARARGS, NULL},
	 { (char *)"delete_OrigTime", _wrap_delete_OrigTime, METH_VARARGS, NULL},
	 { (char *)"OrigTime_swigregister", OrigTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExecValuationPoint", _wrap_new_ExecValuationPoint, METH_VARARGS, NULL},
	 { (char *)"delete_ExecValuationPoint", _wrap_delete_ExecValuationPoint, METH_VARARGS, NULL},
	 { (char *)"ExecValuationPoint_swigregister", ExecValuationPoint_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExecType", _wrap_new_ExecType, METH_VARARGS, NULL},
	 { (char *)"delete_ExecType", _wrap_delete_ExecType, METH_VARARGS, NULL},
	 { (char *)"ExecType_swigregister", ExecType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested4PartyRole", _wrap_new_Nested4PartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_Nested4PartyRole", _wrap_delete_Nested4PartyRole, METH_VARARGS, NULL},
	 { (char *)"Nested4PartyRole_swigregister", Nested4PartyRole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MultilegModel", _wrap_new_MultilegModel, METH_VARARGS, NULL},
	 { (char *)"delete_MultilegModel", _wrap_delete_MultilegModel, METH_VARARGS, NULL},
	 { (char *)"MultilegModel_swigregister", MultilegModel_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityGroup", _wrap_new_SecurityGroup, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityGroup", _wrap_delete_SecurityGroup, METH_VARARGS, NULL},
	 { (char *)"SecurityGroup_swigregister", SecurityGroup_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EventType", _wrap_new_EventType, METH_VARARGS, NULL},
	 { (char *)"delete_EventType", _wrap_delete_EventType, METH_VARARGS, NULL},
	 { (char *)"EventType_swigregister", EventType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeAllocIndicator", _wrap_new_TradeAllocIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_TradeAllocIndicator", _wrap_delete_TradeAllocIndicator, METH_VARARGS, NULL},
	 { (char *)"TradeAllocIndicator_swigregister", TradeAllocIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_YieldCalcDate", _wrap_new_YieldCalcDate, METH_VARARGS, NULL},
	 { (char *)"delete_YieldCalcDate", _wrap_delete_YieldCalcDate, METH_VARARGS, NULL},
	 { (char *)"YieldCalcDate_swigregister", YieldCalcDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ValueOfFutures", _wrap_new_ValueOfFutures, METH_VARARGS, NULL},
	 { (char *)"delete_ValueOfFutures", _wrap_delete_ValueOfFutures, METH_VARARGS, NULL},
	 { (char *)"ValueOfFutures_swigregister", ValueOfFutures_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSide", _wrap_new_LegSide, METH_VARARGS, NULL},
	 { (char *)"delete_LegSide", _wrap_delete_LegSide, METH_VARARGS, NULL},
	 { (char *)"LegSide_swigregister", LegSide_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UserStatus", _wrap_new_UserStatus, METH_VARARGS, NULL},
	 { (char *)"delete_UserStatus", _wrap_delete_UserStatus, METH_VARARGS, NULL},
	 { (char *)"UserStatus_swigregister", UserStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideValue1", _wrap_new_SideValue1, METH_VARARGS, NULL},
	 { (char *)"delete_SideValue1", _wrap_delete_SideValue1, METH_VARARGS, NULL},
	 { (char *)"SideValue1_swigregister", SideValue1_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CxlQty", _wrap_new_CxlQty, METH_VARARGS, NULL},
	 { (char *)"delete_CxlQty", _wrap_delete_CxlQty, METH_VARARGS, NULL},
	 { (char *)"CxlQty_swigregister", CxlQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityResponseID", _wrap_new_SecurityResponseID, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityResponseID", _wrap_delete_SecurityResponseID, METH_VARARGS, NULL},
	 { (char *)"SecurityResponseID_swigregister", SecurityResponseID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InstrRegistry", _wrap_new_InstrRegistry, METH_VARARGS, NULL},
	 { (char *)"delete_InstrRegistry", _wrap_delete_InstrRegistry, METH_VARARGS, NULL},
	 { (char *)"InstrRegistry_swigregister", InstrRegistry_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StreamAsgnRptID", _wrap_new_StreamAsgnRptID, METH_VARARGS, NULL},
	 { (char *)"delete_StreamAsgnRptID", _wrap_delete_StreamAsgnRptID, METH_VARARGS, NULL},
	 { (char *)"StreamAsgnRptID_swigregister", StreamAsgnRptID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrderDelayUnit", _wrap_new_OrderDelayUnit, METH_VARARGS, NULL},
	 { (char *)"delete_OrderDelayUnit", _wrap_delete_OrderDelayUnit, METH_VARARGS, NULL},
	 { (char *)"OrderDelayUnit_swigregister", OrderDelayUnit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegCurrencyRatio", _wrap_new_LegCurrencyRatio, METH_VARARGS, NULL},
	 { (char *)"delete_LegCurrencyRatio", _wrap_delete_LegCurrencyRatio, METH_VARARGS, NULL},
	 { (char *)"LegCurrencyRatio_swigregister", LegCurrencyRatio_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EndTickPriceRange", _wrap_new_EndTickPriceRange, METH_VARARGS, NULL},
	 { (char *)"delete_EndTickPriceRange", _wrap_delete_EndTickPriceRange, METH_VARARGS, NULL},
	 { (char *)"EndTickPriceRange_swigregister", EndTickPriceRange_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollReqID", _wrap_new_CollReqID, METH_VARARGS, NULL},
	 { (char *)"delete_CollReqID", _wrap_delete_CollReqID, METH_VARARGS, NULL},
	 { (char *)"CollReqID_swigregister", CollReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegPool", _wrap_new_LegPool, METH_VARARGS, NULL},
	 { (char *)"delete_LegPool", _wrap_delete_LegPool, METH_VARARGS, NULL},
	 { (char *)"LegPool_swigregister", LegPool_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ShortQty", _wrap_new_ShortQty, METH_VARARGS, NULL},
	 { (char *)"delete_ShortQty", _wrap_delete_ShortQty, METH_VARARGS, NULL},
	 { (char *)"ShortQty_swigregister", ShortQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideValue2", _wrap_new_SideValue2, METH_VARARGS, NULL},
	 { (char *)"delete_SideValue2", _wrap_delete_SideValue2, METH_VARARGS, NULL},
	 { (char *)"SideValue2_swigregister", SideValue2_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradedFlatSwitch", _wrap_new_TradedFlatSwitch, METH_VARARGS, NULL},
	 { (char *)"delete_TradedFlatSwitch", _wrap_delete_TradedFlatSwitch, METH_VARARGS, NULL},
	 { (char *)"TradedFlatSwitch_swigregister", TradedFlatSwitch_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MassStatusReqID", _wrap_new_MassStatusReqID, METH_VARARGS, NULL},
	 { (char *)"delete_MassStatusReqID", _wrap_delete_MassStatusReqID, METH_VARARGS, NULL},
	 { (char *)"MassStatusReqID_swigregister", MassStatusReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ComplexEventEndDate", _wrap_new_ComplexEventEndDate, METH_VARARGS, NULL},
	 { (char *)"delete_ComplexEventEndDate", _wrap_delete_ComplexEventEndDate, METH_VARARGS, NULL},
	 { (char *)"ComplexEventEndDate_swigregister", ComplexEventEndDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MarketID", _wrap_new_MarketID, METH_VARARGS, NULL},
	 { (char *)"delete_MarketID", _wrap_delete_MarketID, METH_VARARGS, NULL},
	 { (char *)"MarketID_swigregister", MarketID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrigTradeDate", _wrap_new_OrigTradeDate, METH_VARARGS, NULL},
	 { (char *)"delete_OrigTradeDate", _wrap_delete_OrigTradeDate, METH_VARARGS, NULL},
	 { (char *)"OrigTradeDate_swigregister", OrigTradeDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PreTradeAnonymity", _wrap_new_PreTradeAnonymity, METH_VARARGS, NULL},
	 { (char *)"delete_PreTradeAnonymity", _wrap_delete_PreTradeAnonymity, METH_VARARGS, NULL},
	 { (char *)"PreTradeAnonymity_swigregister", PreTradeAnonymity_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TrdRptStatus", _wrap_new_TrdRptStatus, METH_VARARGS, NULL},
	 { (char *)"delete_TrdRptStatus", _wrap_delete_TrdRptStatus, METH_VARARGS, NULL},
	 { (char *)"TrdRptStatus_swigregister", TrdRptStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DistribPercentage", _wrap_new_DistribPercentage, METH_VARARGS, NULL},
	 { (char *)"delete_DistribPercentage", _wrap_delete_DistribPercentage, METH_VARARGS, NULL},
	 { (char *)"DistribPercentage_swigregister", DistribPercentage_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteStatus", _wrap_new_QuoteStatus, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteStatus", _wrap_delete_QuoteStatus, METH_VARARGS, NULL},
	 { (char *)"QuoteStatus_swigregister", QuoteStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ClearingAccount", _wrap_new_ClearingAccount, METH_VARARGS, NULL},
	 { (char *)"delete_ClearingAccount", _wrap_delete_ClearingAccount, METH_VARARGS, NULL},
	 { (char *)"ClearingAccount_swigregister", ClearingAccount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TrdMatchID", _wrap_new_TrdMatchID, METH_VARARGS, NULL},
	 { (char *)"delete_TrdMatchID", _wrap_delete_TrdMatchID, METH_VARARGS, NULL},
	 { (char *)"TrdMatchID_swigregister", TrdMatchID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrderInputDevice", _wrap_new_OrderInputDevice, METH_VARARGS, NULL},
	 { (char *)"delete_OrderInputDevice", _wrap_delete_OrderInputDevice, METH_VARARGS, NULL},
	 { (char *)"OrderInputDevice_swigregister", OrderInputDevice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SolicitedFlag", _wrap_new_SolicitedFlag, METH_VARARGS, NULL},
	 { (char *)"delete_SolicitedFlag", _wrap_delete_SolicitedFlag, METH_VARARGS, NULL},
	 { (char *)"SolicitedFlag_swigregister", SolicitedFlag_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TransactTime", _wrap_new_TransactTime, METH_VARARGS, NULL},
	 { (char *)"delete_TransactTime", _wrap_delete_TransactTime, METH_VARARGS, NULL},
	 { (char *)"TransactTime_swigregister", TransactTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingFlowScheduleType", _wrap_new_UnderlyingFlowScheduleType, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingFlowScheduleType", _wrap_delete_UnderlyingFlowScheduleType, METH_VARARGS, NULL},
	 { (char *)"UnderlyingFlowScheduleType_swigregister", UnderlyingFlowScheduleType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingStipValue", _wrap_new_UnderlyingStipValue, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingStipValue", _wrap_delete_UnderlyingStipValue, METH_VARARGS, NULL},
	 { (char *)"UnderlyingStipValue_swigregister", UnderlyingStipValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NextExpectedMsgSeqNum", _wrap_new_NextExpectedMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"delete_NextExpectedMsgSeqNum", _wrap_delete_NextExpectedMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"NextExpectedMsgSeqNum_swigregister", NextExpectedMsgSeqNum_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BenchmarkCurveCurrency", _wrap_new_BenchmarkCurveCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_BenchmarkCurveCurrency", _wrap_delete_BenchmarkCurveCurrency, METH_VARARGS, NULL},
	 { (char *)"BenchmarkCurveCurrency_swigregister", BenchmarkCurveCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CFICode", _wrap_new_CFICode, METH_VARARGS, NULL},
	 { (char *)"delete_CFICode", _wrap_delete_CFICode, METH_VARARGS, NULL},
	 { (char *)"CFICode_swigregister", CFICode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Factor", _wrap_new_Factor, METH_VARARGS, NULL},
	 { (char *)"delete_Factor", _wrap_delete_Factor, METH_VARARGS, NULL},
	 { (char *)"Factor_swigregister", Factor_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastShares", _wrap_new_LastShares, METH_VARARGS, NULL},
	 { (char *)"delete_LastShares", _wrap_delete_LastShares, METH_VARARGS, NULL},
	 { (char *)"LastShares_swigregister", LastShares_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EventTime", _wrap_new_EventTime, METH_VARARGS, NULL},
	 { (char *)"delete_EventTime", _wrap_delete_EventTime, METH_VARARGS, NULL},
	 { (char *)"EventTime_swigregister", EventTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RootPartySubIDType", _wrap_new_RootPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_RootPartySubIDType", _wrap_delete_RootPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"RootPartySubIDType_swigregister", RootPartySubIDType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ShortSaleReason", _wrap_new_ShortSaleReason, METH_VARARGS, NULL},
	 { (char *)"delete_ShortSaleReason", _wrap_delete_ShortSaleReason, METH_VARARGS, NULL},
	 { (char *)"ShortSaleReason_swigregister", ShortSaleReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_XmlData", _wrap_new_XmlData, METH_VARARGS, NULL},
	 { (char *)"delete_XmlData", _wrap_delete_XmlData, METH_VARARGS, NULL},
	 { (char *)"XmlData_swigregister", XmlData_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoTargetPartyIDs", _wrap_new_NoTargetPartyIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoTargetPartyIDs", _wrap_delete_NoTargetPartyIDs, METH_VARARGS, NULL},
	 { (char *)"NoTargetPartyIDs_swigregister", NoTargetPartyIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoRootPartyIDs", _wrap_new_NoRootPartyIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoRootPartyIDs", _wrap_delete_NoRootPartyIDs, METH_VARARGS, NULL},
	 { (char *)"NoRootPartyIDs_swigregister", NoRootPartyIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EventDate", _wrap_new_EventDate, METH_VARARGS, NULL},
	 { (char *)"delete_EventDate", _wrap_delete_EventDate, METH_VARARGS, NULL},
	 { (char *)"EventDate_swigregister", EventDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PegRoundDirection", _wrap_new_PegRoundDirection, METH_VARARGS, NULL},
	 { (char *)"delete_PegRoundDirection", _wrap_delete_PegRoundDirection, METH_VARARGS, NULL},
	 { (char *)"PegRoundDirection_swigregister", PegRoundDirection_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSettlDate", _wrap_new_LegSettlDate, METH_VARARGS, NULL},
	 { (char *)"delete_LegSettlDate", _wrap_delete_LegSettlDate, METH_VARARGS, NULL},
	 { (char *)"LegSettlDate_swigregister", LegSettlDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ModelType", _wrap_new_ModelType, METH_VARARGS, NULL},
	 { (char *)"delete_ModelType", _wrap_delete_ModelType, METH_VARARGS, NULL},
	 { (char *)"ModelType_swigregister", ModelType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DefaultVerIndicator", _wrap_new_DefaultVerIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_DefaultVerIndicator", _wrap_delete_DefaultVerIndicator, METH_VARARGS, NULL},
	 { (char *)"DefaultVerIndicator_swigregister", DefaultVerIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FuturesValuationMethod", _wrap_new_FuturesValuationMethod, METH_VARARGS, NULL},
	 { (char *)"delete_FuturesValuationMethod", _wrap_delete_FuturesValuationMethod, METH_VARARGS, NULL},
	 { (char *)"FuturesValuationMethod_swigregister", FuturesValuationMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlMethod", _wrap_new_SettlMethod, METH_VARARGS, NULL},
	 { (char *)"delete_SettlMethod", _wrap_delete_SettlMethod, METH_VARARGS, NULL},
	 { (char *)"SettlMethod_swigregister", SettlMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingFXRate", _wrap_new_UnderlyingFXRate, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingFXRate", _wrap_delete_UnderlyingFXRate, METH_VARARGS, NULL},
	 { (char *)"UnderlyingFXRate_swigregister", UnderlyingFXRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ConfirmStatus", _wrap_new_ConfirmStatus, METH_VARARGS, NULL},
	 { (char *)"delete_ConfirmStatus", _wrap_delete_ConfirmStatus, METH_VARARGS, NULL},
	 { (char *)"ConfirmStatus_swigregister", ConfirmStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LocateReqd", _wrap_new_LocateReqd, METH_VARARGS, NULL},
	 { (char *)"delete_LocateReqd", _wrap_delete_LocateReqd, METH_VARARGS, NULL},
	 { (char *)"LocateReqd_swigregister", LocateReqd_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PosMaintRptID", _wrap_new_PosMaintRptID, METH_VARARGS, NULL},
	 { (char *)"delete_PosMaintRptID", _wrap_delete_PosMaintRptID, METH_VARARGS, NULL},
	 { (char *)"PosMaintRptID_swigregister", PosMaintRptID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Adjustment", _wrap_new_Adjustment, METH_VARARGS, NULL},
	 { (char *)"delete_Adjustment", _wrap_delete_Adjustment, METH_VARARGS, NULL},
	 { (char *)"Adjustment_swigregister", Adjustment_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StreamAsgnType", _wrap_new_StreamAsgnType, METH_VARARGS, NULL},
	 { (char *)"delete_StreamAsgnType", _wrap_delete_StreamAsgnType, METH_VARARGS, NULL},
	 { (char *)"StreamAsgnType_swigregister", StreamAsgnType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastRptRequested", _wrap_new_LastRptRequested, METH_VARARGS, NULL},
	 { (char *)"delete_LastRptRequested", _wrap_delete_LastRptRequested, METH_VARARGS, NULL},
	 { (char *)"LastRptRequested_swigregister", LastRptRequested_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LocaleOfIssue", _wrap_new_LocaleOfIssue, METH_VARARGS, NULL},
	 { (char *)"delete_LocaleOfIssue", _wrap_delete_LocaleOfIssue, METH_VARARGS, NULL},
	 { (char *)"LocaleOfIssue_swigregister", LocaleOfIssue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SenderSubID", _wrap_new_SenderSubID, METH_VARARGS, NULL},
	 { (char *)"delete_SenderSubID", _wrap_delete_SenderSubID, METH_VARARGS, NULL},
	 { (char *)"SenderSubID_swigregister", SenderSubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HighPx", _wrap_new_HighPx, METH_VARARGS, NULL},
	 { (char *)"delete_HighPx", _wrap_delete_HighPx, METH_VARARGS, NULL},
	 { (char *)"HighPx_swigregister", HighPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocSettlCurrAmt", _wrap_new_AllocSettlCurrAmt, METH_VARARGS, NULL},
	 { (char *)"delete_AllocSettlCurrAmt", _wrap_delete_AllocSettlCurrAmt, METH_VARARGS, NULL},
	 { (char *)"AllocSettlCurrAmt_swigregister", AllocSettlCurrAmt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ComplexEventPriceBoundaryPrecision", _wrap_new_ComplexEventPriceBoundaryPrecision, METH_VARARGS, NULL},
	 { (char *)"delete_ComplexEventPriceBoundaryPrecision", _wrap_delete_ComplexEventPriceBoundaryPrecision, METH_VARARGS, NULL},
	 { (char *)"ComplexEventPriceBoundaryPrecision_swigregister", ComplexEventPriceBoundaryPrecision_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InstrumentPartyRole", _wrap_new_InstrumentPartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_InstrumentPartyRole", _wrap_delete_InstrumentPartyRole, METH_VARARGS, NULL},
	 { (char *)"InstrumentPartyRole_swigregister", InstrumentPartyRole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_YieldRedemptionPrice", _wrap_new_YieldRedemptionPrice, METH_VARARGS, NULL},
	 { (char *)"delete_YieldRedemptionPrice", _wrap_delete_YieldRedemptionPrice, METH_VARARGS, NULL},
	 { (char *)"YieldRedemptionPrice_swigregister", YieldRedemptionPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CumQty", _wrap_new_CumQty, METH_VARARGS, NULL},
	 { (char *)"delete_CumQty", _wrap_delete_CumQty, METH_VARARGS, NULL},
	 { (char *)"CumQty_swigregister", CumQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrigClOrdID", _wrap_new_OrigClOrdID, METH_VARARGS, NULL},
	 { (char *)"delete_OrigClOrdID", _wrap_delete_OrigClOrdID, METH_VARARGS, NULL},
	 { (char *)"OrigClOrdID_swigregister", OrigClOrdID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlSessID", _wrap_new_SettlSessID, METH_VARARGS, NULL},
	 { (char *)"delete_SettlSessID", _wrap_delete_SettlSessID, METH_VARARGS, NULL},
	 { (char *)"SettlSessID_swigregister", SettlSessID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ParentMktSegmID", _wrap_new_ParentMktSegmID, METH_VARARGS, NULL},
	 { (char *)"delete_ParentMktSegmID", _wrap_delete_ParentMktSegmID, METH_VARARGS, NULL},
	 { (char *)"ParentMktSegmID_swigregister", ParentMktSegmID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeReportType", _wrap_new_TradeReportType, METH_VARARGS, NULL},
	 { (char *)"delete_TradeReportType", _wrap_delete_TradeReportType, METH_VARARGS, NULL},
	 { (char *)"TradeReportType_swigregister", TradeReportType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AvgPrxPrecision", _wrap_new_AvgPrxPrecision, METH_VARARGS, NULL},
	 { (char *)"delete_AvgPrxPrecision", _wrap_delete_AvgPrxPrecision, METH_VARARGS, NULL},
	 { (char *)"AvgPrxPrecision_swigregister", AvgPrxPrecision_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoLegs", _wrap_new_NoLegs, METH_VARARGS, NULL},
	 { (char *)"delete_NoLegs", _wrap_delete_NoLegs, METH_VARARGS, NULL},
	 { (char *)"NoLegs_swigregister", NoLegs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSymbol", _wrap_new_UnderlyingSymbol, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSymbol", _wrap_delete_UnderlyingSymbol, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSymbol_swigregister", UnderlyingSymbol_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExerciseStyle", _wrap_new_ExerciseStyle, METH_VARARGS, NULL},
	 { (char *)"delete_ExerciseStyle", _wrap_delete_ExerciseStyle, METH_VARARGS, NULL},
	 { (char *)"ExerciseStyle_swigregister", ExerciseStyle_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HaltReasonChar", _wrap_new_HaltReasonChar, METH_VARARGS, NULL},
	 { (char *)"delete_HaltReasonChar", _wrap_delete_HaltReasonChar, METH_VARARGS, NULL},
	 { (char *)"HaltReasonChar_swigregister", HaltReasonChar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExDestination", _wrap_new_ExDestination, METH_VARARGS, NULL},
	 { (char *)"delete_ExDestination", _wrap_delete_ExDestination, METH_VARARGS, NULL},
	 { (char *)"ExDestination_swigregister", ExDestination_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeInstrmtAssignmentMethod", _wrap_new_DerivativeInstrmtAssignmentMethod, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeInstrmtAssignmentMethod", _wrap_delete_DerivativeInstrmtAssignmentMethod, METH_VARARGS, NULL},
	 { (char *)"DerivativeInstrmtAssignmentMethod_swigregister", DerivativeInstrmtAssignmentMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingIDSource", _wrap_new_UnderlyingIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingIDSource", _wrap_delete_UnderlyingIDSource, METH_VARARGS, NULL},
	 { (char *)"UnderlyingIDSource_swigregister", UnderlyingIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AdvId", _wrap_new_AdvId, METH_VARARGS, NULL},
	 { (char *)"delete_AdvId", _wrap_delete_AdvId, METH_VARARGS, NULL},
	 { (char *)"AdvId_swigregister", AdvId_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TransBkdTime", _wrap_new_TransBkdTime, METH_VARARGS, NULL},
	 { (char *)"delete_TransBkdTime", _wrap_delete_TransBkdTime, METH_VARARGS, NULL},
	 { (char *)"TransBkdTime_swigregister", TransBkdTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegLastPx", _wrap_new_LegLastPx, METH_VARARGS, NULL},
	 { (char *)"delete_LegLastPx", _wrap_delete_LegLastPx, METH_VARARGS, NULL},
	 { (char *)"LegLastPx_swigregister", LegLastPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocReportType", _wrap_new_AllocReportType, METH_VARARGS, NULL},
	 { (char *)"delete_AllocReportType", _wrap_delete_AllocReportType, METH_VARARGS, NULL},
	 { (char *)"AllocReportType_swigregister", AllocReportType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RegistDtls", _wrap_new_RegistDtls, METH_VARARGS, NULL},
	 { (char *)"delete_RegistDtls", _wrap_delete_RegistDtls, METH_VARARGS, NULL},
	 { (char *)"RegistDtls_swigregister", RegistDtls_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocType", _wrap_new_AllocType, METH_VARARGS, NULL},
	 { (char *)"delete_AllocType", _wrap_delete_AllocType, METH_VARARGS, NULL},
	 { (char *)"AllocType_swigregister", AllocType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteRequestRejectReason", _wrap_new_QuoteRequestRejectReason, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteRequestRejectReason", _wrap_delete_QuoteRequestRejectReason, METH_VARARGS, NULL},
	 { (char *)"QuoteRequestRejectReason_swigregister", QuoteRequestRejectReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingUnitOfMeasure", _wrap_new_UnderlyingUnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingUnitOfMeasure", _wrap_delete_UnderlyingUnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"UnderlyingUnitOfMeasure_swigregister", UnderlyingUnitOfMeasure_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IndividualAllocID", _wrap_new_IndividualAllocID, METH_VARARGS, NULL},
	 { (char *)"delete_IndividualAllocID", _wrap_delete_IndividualAllocID, METH_VARARGS, NULL},
	 { (char *)"IndividualAllocID_swigregister", IndividualAllocID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegOfferPx", _wrap_new_LegOfferPx, METH_VARARGS, NULL},
	 { (char *)"delete_LegOfferPx", _wrap_delete_LegOfferPx, METH_VARARGS, NULL},
	 { (char *)"LegOfferPx_swigregister", LegOfferPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LiquidityIndType", _wrap_new_LiquidityIndType, METH_VARARGS, NULL},
	 { (char *)"delete_LiquidityIndType", _wrap_delete_LiquidityIndType, METH_VARARGS, NULL},
	 { (char *)"LiquidityIndType_swigregister", LiquidityIndType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HopSendingTime", _wrap_new_HopSendingTime, METH_VARARGS, NULL},
	 { (char *)"delete_HopSendingTime", _wrap_delete_HopSendingTime, METH_VARARGS, NULL},
	 { (char *)"HopSendingTime_swigregister", HopSendingTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplResendFlag", _wrap_new_ApplResendFlag, METH_VARARGS, NULL},
	 { (char *)"delete_ApplResendFlag", _wrap_delete_ApplResendFlag, METH_VARARGS, NULL},
	 { (char *)"ApplResendFlag_swigregister", ApplResendFlag_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeCapPrice", _wrap_new_DerivativeCapPrice, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeCapPrice", _wrap_delete_DerivativeCapPrice, METH_VARARGS, NULL},
	 { (char *)"DerivativeCapPrice_swigregister", DerivativeCapPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ComplexOptPayoutAmount", _wrap_new_ComplexOptPayoutAmount, METH_VARARGS, NULL},
	 { (char *)"delete_ComplexOptPayoutAmount", _wrap_delete_ComplexOptPayoutAmount, METH_VARARGS, NULL},
	 { (char *)"ComplexOptPayoutAmount_swigregister", ComplexOptPayoutAmount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LanguageCode", _wrap_new_LanguageCode, METH_VARARGS, NULL},
	 { (char *)"delete_LanguageCode", _wrap_delete_LanguageCode, METH_VARARGS, NULL},
	 { (char *)"LanguageCode_swigregister", LanguageCode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlObligRefID", _wrap_new_SettlObligRefID, METH_VARARGS, NULL},
	 { (char *)"delete_SettlObligRefID", _wrap_delete_SettlObligRefID, METH_VARARGS, NULL},
	 { (char *)"SettlObligRefID_swigregister", SettlObligRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrigTradeID", _wrap_new_OrigTradeID, METH_VARARGS, NULL},
	 { (char *)"delete_OrigTradeID", _wrap_delete_OrigTradeID, METH_VARARGS, NULL},
	 { (char *)"OrigTradeID_swigregister", OrigTradeID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingCollectAmount", _wrap_new_UnderlyingCollectAmount, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingCollectAmount", _wrap_delete_UnderlyingCollectAmount, METH_VARARGS, NULL},
	 { (char *)"UnderlyingCollectAmount_swigregister", UnderlyingCollectAmount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StatusValue", _wrap_new_StatusValue, METH_VARARGS, NULL},
	 { (char *)"delete_StatusValue", _wrap_delete_StatusValue, METH_VARARGS, NULL},
	 { (char *)"StatusValue_swigregister", StatusValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OfferSpotRate", _wrap_new_OfferSpotRate, METH_VARARGS, NULL},
	 { (char *)"delete_OfferSpotRate", _wrap_delete_OfferSpotRate, METH_VARARGS, NULL},
	 { (char *)"OfferSpotRate_swigregister", OfferSpotRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PosType", _wrap_new_PosType, METH_VARARGS, NULL},
	 { (char *)"delete_PosType", _wrap_delete_PosType, METH_VARARGS, NULL},
	 { (char *)"PosType_swigregister", PosType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingRedemptionDate", _wrap_new_UnderlyingRedemptionDate, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingRedemptionDate", _wrap_delete_UnderlyingRedemptionDate, METH_VARARGS, NULL},
	 { (char *)"UnderlyingRedemptionDate_swigregister", UnderlyingRedemptionDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlDepositoryCode", _wrap_new_SettlDepositoryCode, METH_VARARGS, NULL},
	 { (char *)"delete_SettlDepositoryCode", _wrap_delete_SettlDepositoryCode, METH_VARARGS, NULL},
	 { (char *)"SettlDepositoryCode_swigregister", SettlDepositoryCode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StreamAsgnAckType", _wrap_new_StreamAsgnAckType, METH_VARARGS, NULL},
	 { (char *)"delete_StreamAsgnAckType", _wrap_delete_StreamAsgnAckType, METH_VARARGS, NULL},
	 { (char *)"StreamAsgnAckType_swigregister", StreamAsgnAckType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FloorPrice", _wrap_new_FloorPrice, METH_VARARGS, NULL},
	 { (char *)"delete_FloorPrice", _wrap_delete_FloorPrice, METH_VARARGS, NULL},
	 { (char *)"FloorPrice_swigregister", FloorPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingPriceUnitOfMeasureQty", _wrap_new_UnderlyingPriceUnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingPriceUnitOfMeasureQty", _wrap_delete_UnderlyingPriceUnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"UnderlyingPriceUnitOfMeasureQty_swigregister", UnderlyingPriceUnitOfMeasureQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FeeMultiplier", _wrap_new_FeeMultiplier, METH_VARARGS, NULL},
	 { (char *)"delete_FeeMultiplier", _wrap_delete_FeeMultiplier, METH_VARARGS, NULL},
	 { (char *)"FeeMultiplier_swigregister", FeeMultiplier_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingMaturityTime", _wrap_new_UnderlyingMaturityTime, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingMaturityTime", _wrap_delete_UnderlyingMaturityTime, METH_VARARGS, NULL},
	 { (char *)"UnderlyingMaturityTime_swigregister", UnderlyingMaturityTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplID", _wrap_new_ApplID, METH_VARARGS, NULL},
	 { (char *)"delete_ApplID", _wrap_delete_ApplID, METH_VARARGS, NULL},
	 { (char *)"ApplID_swigregister", ApplID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegGrossTradeAmt", _wrap_new_LegGrossTradeAmt, METH_VARARGS, NULL},
	 { (char *)"delete_LegGrossTradeAmt", _wrap_delete_LegGrossTradeAmt, METH_VARARGS, NULL},
	 { (char *)"LegGrossTradeAmt_swigregister", LegGrossTradeAmt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDEntryDate", _wrap_new_MDEntryDate, METH_VARARGS, NULL},
	 { (char *)"delete_MDEntryDate", _wrap_delete_MDEntryDate, METH_VARARGS, NULL},
	 { (char *)"MDEntryDate_swigregister", MDEntryDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegBenchmarkCurveCurrency", _wrap_new_LegBenchmarkCurveCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_LegBenchmarkCurveCurrency", _wrap_delete_LegBenchmarkCurveCurrency, METH_VARARGS, NULL},
	 { (char *)"LegBenchmarkCurveCurrency_swigregister", LegBenchmarkCurveCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OptPayoutAmount", _wrap_new_OptPayoutAmount, METH_VARARGS, NULL},
	 { (char *)"delete_OptPayoutAmount", _wrap_delete_OptPayoutAmount, METH_VARARGS, NULL},
	 { (char *)"OptPayoutAmount_swigregister", OptPayoutAmount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MiscFeeBasis", _wrap_new_MiscFeeBasis, METH_VARARGS, NULL},
	 { (char *)"delete_MiscFeeBasis", _wrap_delete_MiscFeeBasis, METH_VARARGS, NULL},
	 { (char *)"MiscFeeBasis_swigregister", MiscFeeBasis_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ValidUntilTime", _wrap_new_ValidUntilTime, METH_VARARGS, NULL},
	 { (char *)"delete_ValidUntilTime", _wrap_delete_ValidUntilTime, METH_VARARGS, NULL},
	 { (char *)"ValidUntilTime_swigregister", ValidUntilTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrdType", _wrap_new_OrdType, METH_VARARGS, NULL},
	 { (char *)"delete_OrdType", _wrap_delete_OrdType, METH_VARARGS, NULL},
	 { (char *)"OrdType_swigregister", OrdType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AdvRefID", _wrap_new_AdvRefID, METH_VARARGS, NULL},
	 { (char *)"delete_AdvRefID", _wrap_delete_AdvRefID, METH_VARARGS, NULL},
	 { (char *)"AdvRefID_swigregister", AdvRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HopCompID", _wrap_new_HopCompID, METH_VARARGS, NULL},
	 { (char *)"delete_HopCompID", _wrap_delete_HopCompID, METH_VARARGS, NULL},
	 { (char *)"HopCompID_swigregister", HopCompID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PosMaintRptRefID", _wrap_new_PosMaintRptRefID, METH_VARARGS, NULL},
	 { (char *)"delete_PosMaintRptRefID", _wrap_delete_PosMaintRptRefID, METH_VARARGS, NULL},
	 { (char *)"PosMaintRptRefID_swigregister", PosMaintRptRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegStipulationValue", _wrap_new_LegStipulationValue, METH_VARARGS, NULL},
	 { (char *)"delete_LegStipulationValue", _wrap_delete_LegStipulationValue, METH_VARARGS, NULL},
	 { (char *)"LegStipulationValue_swigregister", LegStipulationValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MatchType", _wrap_new_MatchType, METH_VARARGS, NULL},
	 { (char *)"delete_MatchType", _wrap_delete_MatchType, METH_VARARGS, NULL},
	 { (char *)"MatchType_swigregister", MatchType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OptPayoutType", _wrap_new_OptPayoutType, METH_VARARGS, NULL},
	 { (char *)"delete_OptPayoutType", _wrap_delete_OptPayoutType, METH_VARARGS, NULL},
	 { (char *)"OptPayoutType_swigregister", OptPayoutType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingPriceUnitOfMeasure", _wrap_new_UnderlyingPriceUnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingPriceUnitOfMeasure", _wrap_delete_UnderlyingPriceUnitOfMeasure, METH_VARARGS, NULL},
	 { (char *)"UnderlyingPriceUnitOfMeasure_swigregister", UnderlyingPriceUnitOfMeasure_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MarketUpdateAction", _wrap_new_MarketUpdateAction, METH_VARARGS, NULL},
	 { (char *)"delete_MarketUpdateAction", _wrap_delete_MarketUpdateAction, METH_VARARGS, NULL},
	 { (char *)"MarketUpdateAction_swigregister", MarketUpdateAction_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollAsgnRejectReason", _wrap_new_CollAsgnRejectReason, METH_VARARGS, NULL},
	 { (char *)"delete_CollAsgnRejectReason", _wrap_delete_CollAsgnRejectReason, METH_VARARGS, NULL},
	 { (char *)"CollAsgnRejectReason_swigregister", CollAsgnRejectReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PeggedRefPrice", _wrap_new_PeggedRefPrice, METH_VARARGS, NULL},
	 { (char *)"delete_PeggedRefPrice", _wrap_delete_PeggedRefPrice, METH_VARARGS, NULL},
	 { (char *)"PeggedRefPrice_swigregister", PeggedRefPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IndividualAllocType", _wrap_new_IndividualAllocType, METH_VARARGS, NULL},
	 { (char *)"delete_IndividualAllocType", _wrap_delete_IndividualAllocType, METH_VARARGS, NULL},
	 { (char *)"IndividualAllocType_swigregister", IndividualAllocType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EndCash", _wrap_new_EndCash, METH_VARARGS, NULL},
	 { (char *)"delete_EndCash", _wrap_delete_EndCash, METH_VARARGS, NULL},
	 { (char *)"EndCash_swigregister", EndCash_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EventText", _wrap_new_EventText, METH_VARARGS, NULL},
	 { (char *)"delete_EventText", _wrap_delete_EventText, METH_VARARGS, NULL},
	 { (char *)"EventText_swigregister", EventText_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExDate", _wrap_new_ExDate, METH_VARARGS, NULL},
	 { (char *)"delete_ExDate", _wrap_delete_ExDate, METH_VARARGS, NULL},
	 { (char *)"ExDate_swigregister", ExDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NestedPartyIDSource", _wrap_new_NestedPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_NestedPartyIDSource", _wrap_delete_NestedPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"NestedPartyIDSource_swigregister", NestedPartyIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_GTBookingInst", _wrap_new_GTBookingInst, METH_VARARGS, NULL},
	 { (char *)"delete_GTBookingInst", _wrap_delete_GTBookingInst, METH_VARARGS, NULL},
	 { (char *)"GTBookingInst_swigregister", GTBookingInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeValuationMethod", _wrap_new_DerivativeValuationMethod, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeValuationMethod", _wrap_delete_DerivativeValuationMethod, METH_VARARGS, NULL},
	 { (char *)"DerivativeValuationMethod_swigregister", DerivativeValuationMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NumberOfOrders", _wrap_new_NumberOfOrders, METH_VARARGS, NULL},
	 { (char *)"delete_NumberOfOrders", _wrap_delete_NumberOfOrders, METH_VARARGS, NULL},
	 { (char *)"NumberOfOrders_swigregister", NumberOfOrders_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TrdRepPartyRole", _wrap_new_TrdRepPartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_TrdRepPartyRole", _wrap_delete_TrdRepPartyRole, METH_VARARGS, NULL},
	 { (char *)"TrdRepPartyRole_swigregister", TrdRepPartyRole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerPrice", _wrap_new_TriggerPrice, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerPrice", _wrap_delete_TriggerPrice, METH_VARARGS, NULL},
	 { (char *)"TriggerPrice_swigregister", TriggerPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDReportID", _wrap_new_MDReportID, METH_VARARGS, NULL},
	 { (char *)"delete_MDReportID", _wrap_delete_MDReportID, METH_VARARGS, NULL},
	 { (char *)"MDReportID_swigregister", MDReportID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryAllocID", _wrap_new_SecondaryAllocID, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryAllocID", _wrap_delete_SecondaryAllocID, METH_VARARGS, NULL},
	 { (char *)"SecondaryAllocID_swigregister", SecondaryAllocID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LeavesQty", _wrap_new_LeavesQty, METH_VARARGS, NULL},
	 { (char *)"delete_LeavesQty", _wrap_delete_LeavesQty, METH_VARARGS, NULL},
	 { (char *)"LeavesQty_swigregister", LeavesQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CardStartDate", _wrap_new_CardStartDate, METH_VARARGS, NULL},
	 { (char *)"delete_CardStartDate", _wrap_delete_CardStartDate, METH_VARARGS, NULL},
	 { (char *)"CardStartDate_swigregister", CardStartDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegCoveredOrUncovered", _wrap_new_LegCoveredOrUncovered, METH_VARARGS, NULL},
	 { (char *)"delete_LegCoveredOrUncovered", _wrap_delete_LegCoveredOrUncovered, METH_VARARGS, NULL},
	 { (char *)"LegCoveredOrUncovered_swigregister", LegCoveredOrUncovered_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PutOrCall", _wrap_new_PutOrCall, METH_VARARGS, NULL},
	 { (char *)"delete_PutOrCall", _wrap_delete_PutOrCall, METH_VARARGS, NULL},
	 { (char *)"PutOrCall_swigregister", PutOrCall_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MatchAlgorithm", _wrap_new_MatchAlgorithm, METH_VARARGS, NULL},
	 { (char *)"delete_MatchAlgorithm", _wrap_delete_MatchAlgorithm, METH_VARARGS, NULL},
	 { (char *)"MatchAlgorithm_swigregister", MatchAlgorithm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CalculatedCcyLastQty", _wrap_new_CalculatedCcyLastQty, METH_VARARGS, NULL},
	 { (char *)"delete_CalculatedCcyLastQty", _wrap_delete_CalculatedCcyLastQty, METH_VARARGS, NULL},
	 { (char *)"CalculatedCcyLastQty_swigregister", CalculatedCcyLastQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FundRenewWaiv", _wrap_new_FundRenewWaiv, METH_VARARGS, NULL},
	 { (char *)"delete_FundRenewWaiv", _wrap_delete_FundRenewWaiv, METH_VARARGS, NULL},
	 { (char *)"FundRenewWaiv_swigregister", FundRenewWaiv_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecuritySettlAgentName", _wrap_new_SecuritySettlAgentName, METH_VARARGS, NULL},
	 { (char *)"delete_SecuritySettlAgentName", _wrap_delete_SecuritySettlAgentName, METH_VARARGS, NULL},
	 { (char *)"SecuritySettlAgentName_swigregister", SecuritySettlAgentName_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BidDescriptor", _wrap_new_BidDescriptor, METH_VARARGS, NULL},
	 { (char *)"delete_BidDescriptor", _wrap_delete_BidDescriptor, METH_VARARGS, NULL},
	 { (char *)"BidDescriptor_swigregister", BidDescriptor_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDStreamID", _wrap_new_MDStreamID, METH_VARARGS, NULL},
	 { (char *)"delete_MDStreamID", _wrap_delete_MDStreamID, METH_VARARGS, NULL},
	 { (char *)"MDStreamID_swigregister", MDStreamID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoAsgnReqs", _wrap_new_NoAsgnReqs, METH_VARARGS, NULL},
	 { (char *)"delete_NoAsgnReqs", _wrap_delete_NoAsgnReqs, METH_VARARGS, NULL},
	 { (char *)"NoAsgnReqs_swigregister", NoAsgnReqs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NotionalPercentageOutstanding", _wrap_new_NotionalPercentageOutstanding, METH_VARARGS, NULL},
	 { (char *)"delete_NotionalPercentageOutstanding", _wrap_delete_NotionalPercentageOutstanding, METH_VARARGS, NULL},
	 { (char *)"NotionalPercentageOutstanding_swigregister", NotionalPercentageOutstanding_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoSettlInst", _wrap_new_NoSettlInst, METH_VARARGS, NULL},
	 { (char *)"delete_NoSettlInst", _wrap_delete_NoSettlInst, METH_VARARGS, NULL},
	 { (char *)"NoSettlInst_swigregister", NoSettlInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlInstMsgID", _wrap_new_SettlInstMsgID, METH_VARARGS, NULL},
	 { (char *)"delete_SettlInstMsgID", _wrap_delete_SettlInstMsgID, METH_VARARGS, NULL},
	 { (char *)"SettlInstMsgID_swigregister", SettlInstMsgID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ForexReq", _wrap_new_ForexReq, METH_VARARGS, NULL},
	 { (char *)"delete_ForexReq", _wrap_delete_ForexReq, METH_VARARGS, NULL},
	 { (char *)"ForexReq_swigregister", ForexReq_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradSesReqID", _wrap_new_TradSesReqID, METH_VARARGS, NULL},
	 { (char *)"delete_TradSesReqID", _wrap_delete_TradSesReqID, METH_VARARGS, NULL},
	 { (char *)"TradSesReqID_swigregister", TradSesReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegStrikePrice", _wrap_new_UnderlyingLegStrikePrice, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegStrikePrice", _wrap_delete_UnderlyingLegStrikePrice, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegStrikePrice_swigregister", UnderlyingLegStrikePrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TickRuleType", _wrap_new_TickRuleType, METH_VARARGS, NULL},
	 { (char *)"delete_TickRuleType", _wrap_delete_TickRuleType, METH_VARARGS, NULL},
	 { (char *)"TickRuleType_swigregister", TickRuleType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InstrmtAssignmentMethod", _wrap_new_InstrmtAssignmentMethod, METH_VARARGS, NULL},
	 { (char *)"delete_InstrmtAssignmentMethod", _wrap_delete_InstrmtAssignmentMethod, METH_VARARGS, NULL},
	 { (char *)"InstrmtAssignmentMethod_swigregister", InstrmtAssignmentMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DiscretionOffsetType", _wrap_new_DiscretionOffsetType, METH_VARARGS, NULL},
	 { (char *)"delete_DiscretionOffsetType", _wrap_delete_DiscretionOffsetType, METH_VARARGS, NULL},
	 { (char *)"DiscretionOffsetType_swigregister", DiscretionOffsetType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ConfirmTransType", _wrap_new_ConfirmTransType, METH_VARARGS, NULL},
	 { (char *)"delete_ConfirmTransType", _wrap_delete_ConfirmTransType, METH_VARARGS, NULL},
	 { (char *)"ConfirmTransType_swigregister", ConfirmTransType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotalTakedown", _wrap_new_TotalTakedown, METH_VARARGS, NULL},
	 { (char *)"delete_TotalTakedown", _wrap_delete_TotalTakedown, METH_VARARGS, NULL},
	 { (char *)"TotalTakedown_swigregister", TotalTakedown_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResponseDestination", _wrap_new_ResponseDestination, METH_VARARGS, NULL},
	 { (char *)"delete_ResponseDestination", _wrap_delete_ResponseDestination, METH_VARARGS, NULL},
	 { (char *)"ResponseDestination_swigregister", ResponseDestination_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDSecSizeType", _wrap_new_MDSecSizeType, METH_VARARGS, NULL},
	 { (char *)"delete_MDSecSizeType", _wrap_delete_MDSecSizeType, METH_VARARGS, NULL},
	 { (char *)"MDSecSizeType_swigregister", MDSecSizeType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InstrumentPartySubIDType", _wrap_new_InstrumentPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_InstrumentPartySubIDType", _wrap_delete_InstrumentPartySubIDType, METH_VARARGS, NULL},
	 { (char *)"InstrumentPartySubIDType_swigregister", InstrumentPartySubIDType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegTimeUnit", _wrap_new_LegTimeUnit, METH_VARARGS, NULL},
	 { (char *)"delete_LegTimeUnit", _wrap_delete_LegTimeUnit, METH_VARARGS, NULL},
	 { (char *)"LegTimeUnit_swigregister", LegTimeUnit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TransferReason", _wrap_new_TransferReason, METH_VARARGS, NULL},
	 { (char *)"delete_TransferReason", _wrap_delete_TransferReason, METH_VARARGS, NULL},
	 { (char *)"TransferReason_swigregister", TransferReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplQueueMax", _wrap_new_ApplQueueMax, METH_VARARGS, NULL},
	 { (char *)"delete_ApplQueueMax", _wrap_delete_ApplQueueMax, METH_VARARGS, NULL},
	 { (char *)"ApplQueueMax_swigregister", ApplQueueMax_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DiscretionOffsetValue", _wrap_new_DiscretionOffsetValue, METH_VARARGS, NULL},
	 { (char *)"delete_DiscretionOffsetValue", _wrap_delete_DiscretionOffsetValue, METH_VARARGS, NULL},
	 { (char *)"DiscretionOffsetValue_swigregister", DiscretionOffsetValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BookingRefID", _wrap_new_BookingRefID, METH_VARARGS, NULL},
	 { (char *)"delete_BookingRefID", _wrap_delete_BookingRefID, METH_VARARGS, NULL},
	 { (char *)"BookingRefID_swigregister", BookingRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegBidPx", _wrap_new_LegBidPx, METH_VARARGS, NULL},
	 { (char *)"delete_LegBidPx", _wrap_delete_LegBidPx, METH_VARARGS, NULL},
	 { (char *)"LegBidPx_swigregister", LegBidPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradSesEvent", _wrap_new_TradSesEvent, METH_VARARGS, NULL},
	 { (char *)"delete_TradSesEvent", _wrap_delete_TradSesEvent, METH_VARARGS, NULL},
	 { (char *)"TradSesEvent_swigregister", TradSesEvent_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeProduct", _wrap_new_DerivativeProduct, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeProduct", _wrap_delete_DerivativeProduct, METH_VARARGS, NULL},
	 { (char *)"DerivativeProduct_swigregister", DerivativeProduct_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RootPartyRole", _wrap_new_RootPartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_RootPartyRole", _wrap_delete_RootPartyRole, METH_VARARGS, NULL},
	 { (char *)"RootPartyRole_swigregister", RootPartyRole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DlvyInstType", _wrap_new_DlvyInstType, METH_VARARGS, NULL},
	 { (char *)"delete_DlvyInstType", _wrap_delete_DlvyInstType, METH_VARARGS, NULL},
	 { (char *)"DlvyInstType_swigregister", DlvyInstType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoLinesOfText", _wrap_new_NoLinesOfText, METH_VARARGS, NULL},
	 { (char *)"delete_NoLinesOfText", _wrap_delete_NoLinesOfText, METH_VARARGS, NULL},
	 { (char *)"NoLinesOfText_swigregister", NoLinesOfText_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PosReqID", _wrap_new_PosReqID, METH_VARARGS, NULL},
	 { (char *)"delete_PosReqID", _wrap_delete_PosReqID, METH_VARARGS, NULL},
	 { (char *)"PosReqID_swigregister", PosReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSecurityAltIDSource", _wrap_new_LegSecurityAltIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_LegSecurityAltIDSource", _wrap_delete_LegSecurityAltIDSource, METH_VARARGS, NULL},
	 { (char *)"LegSecurityAltIDSource_swigregister", LegSecurityAltIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedSubject", _wrap_new_EncodedSubject, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedSubject", _wrap_delete_EncodedSubject, METH_VARARGS, NULL},
	 { (char *)"EncodedSubject_swigregister", EncodedSubject_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ContraBroker", _wrap_new_ContraBroker, METH_VARARGS, NULL},
	 { (char *)"delete_ContraBroker", _wrap_delete_ContraBroker, METH_VARARGS, NULL},
	 { (char *)"ContraBroker_swigregister", ContraBroker_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeCondition", _wrap_new_TradeCondition, METH_VARARGS, NULL},
	 { (char *)"delete_TradeCondition", _wrap_delete_TradeCondition, METH_VARARGS, NULL},
	 { (char *)"TradeCondition_swigregister", TradeCondition_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PartyID", _wrap_new_PartyID, METH_VARARGS, NULL},
	 { (char *)"delete_PartyID", _wrap_delete_PartyID, METH_VARARGS, NULL},
	 { (char *)"PartyID_swigregister", PartyID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDEntryID", _wrap_new_MDEntryID, METH_VARARGS, NULL},
	 { (char *)"delete_MDEntryID", _wrap_delete_MDEntryID, METH_VARARGS, NULL},
	 { (char *)"MDEntryID_swigregister", MDEntryID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegSecurityExchange", _wrap_new_UnderlyingLegSecurityExchange, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegSecurityExchange", _wrap_delete_UnderlyingLegSecurityExchange, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegSecurityExchange_swigregister", UnderlyingLegSecurityExchange_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PriceLimitType", _wrap_new_PriceLimitType, METH_VARARGS, NULL},
	 { (char *)"delete_PriceLimitType", _wrap_delete_PriceLimitType, METH_VARARGS, NULL},
	 { (char *)"PriceLimitType_swigregister", PriceLimitType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerSecurityIDSource", _wrap_new_TriggerSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerSecurityIDSource", _wrap_delete_TriggerSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"TriggerSecurityIDSource_swigregister", TriggerSecurityIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoUndlyInstrumentPartySubIDs", _wrap_new_NoUndlyInstrumentPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoUndlyInstrumentPartySubIDs", _wrap_delete_NoUndlyInstrumentPartySubIDs, METH_VARARGS, NULL},
	 { (char *)"NoUndlyInstrumentPartySubIDs_swigregister", NoUndlyInstrumentPartySubIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ClientBidID", _wrap_new_ClientBidID, METH_VARARGS, NULL},
	 { (char *)"delete_ClientBidID", _wrap_delete_ClientBidID, METH_VARARGS, NULL},
	 { (char *)"ClientBidID_swigregister", ClientBidID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NetChgPrevDay", _wrap_new_NetChgPrevDay, METH_VARARGS, NULL},
	 { (char *)"delete_NetChgPrevDay", _wrap_delete_NetChgPrevDay, METH_VARARGS, NULL},
	 { (char *)"NetChgPrevDay_swigregister", NetChgPrevDay_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DefaultApplVerID", _wrap_new_DefaultApplVerID, METH_VARARGS, NULL},
	 { (char *)"delete_DefaultApplVerID", _wrap_delete_DefaultApplVerID, METH_VARARGS, NULL},
	 { (char *)"DefaultApplVerID_swigregister", DefaultApplVerID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IOIID", _wrap_new_IOIID, METH_VARARGS, NULL},
	 { (char *)"delete_IOIID", _wrap_delete_IOIID, METH_VARARGS, NULL},
	 { (char *)"IOIID_swigregister", IOIID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SpreadToBenchmark", _wrap_new_SpreadToBenchmark, METH_VARARGS, NULL},
	 { (char *)"delete_SpreadToBenchmark", _wrap_delete_SpreadToBenchmark, METH_VARARGS, NULL},
	 { (char *)"SpreadToBenchmark_swigregister", SpreadToBenchmark_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CommType", _wrap_new_CommType, METH_VARARGS, NULL},
	 { (char *)"delete_CommType", _wrap_delete_CommType, METH_VARARGS, NULL},
	 { (char *)"CommType_swigregister", CommType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RegistRejReasonCode", _wrap_new_RegistRejReasonCode, METH_VARARGS, NULL},
	 { (char *)"delete_RegistRejReasonCode", _wrap_delete_RegistRejReasonCode, METH_VARARGS, NULL},
	 { (char *)"RegistRejReasonCode_swigregister", RegistRejReasonCode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideTimeInForce", _wrap_new_SideTimeInForce, METH_VARARGS, NULL},
	 { (char *)"delete_SideTimeInForce", _wrap_delete_SideTimeInForce, METH_VARARGS, NULL},
	 { (char *)"SideTimeInForce_swigregister", SideTimeInForce_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TrdRegTimestamp", _wrap_new_TrdRegTimestamp, METH_VARARGS, NULL},
	 { (char *)"delete_TrdRegTimestamp", _wrap_delete_TrdRegTimestamp, METH_VARARGS, NULL},
	 { (char *)"TrdRegTimestamp_swigregister", TrdRegTimestamp_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FinancialStatus", _wrap_new_FinancialStatus, METH_VARARGS, NULL},
	 { (char *)"delete_FinancialStatus", _wrap_delete_FinancialStatus, METH_VARARGS, NULL},
	 { (char *)"FinancialStatus_swigregister", FinancialStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoTrades", _wrap_new_NoTrades, METH_VARARGS, NULL},
	 { (char *)"delete_NoTrades", _wrap_delete_NoTrades, METH_VARARGS, NULL},
	 { (char *)"NoTrades_swigregister", NoTrades_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastFragment", _wrap_new_LastFragment, METH_VARARGS, NULL},
	 { (char *)"delete_LastFragment", _wrap_delete_LastFragment, METH_VARARGS, NULL},
	 { (char *)"LastFragment_swigregister", LastFragment_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PartySubID", _wrap_new_PartySubID, METH_VARARGS, NULL},
	 { (char *)"delete_PartySubID", _wrap_delete_PartySubID, METH_VARARGS, NULL},
	 { (char *)"PartySubID_swigregister", PartySubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocQty", _wrap_new_AllocQty, METH_VARARGS, NULL},
	 { (char *)"delete_AllocQty", _wrap_delete_AllocQty, METH_VARARGS, NULL},
	 { (char *)"AllocQty_swigregister", AllocQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NotifyBrokerOfCredit", _wrap_new_NotifyBrokerOfCredit, METH_VARARGS, NULL},
	 { (char *)"delete_NotifyBrokerOfCredit", _wrap_delete_NotifyBrokerOfCredit, METH_VARARGS, NULL},
	 { (char *)"NotifyBrokerOfCredit_swigregister", NotifyBrokerOfCredit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideTrdRegTimestampType", _wrap_new_SideTrdRegTimestampType, METH_VARARGS, NULL},
	 { (char *)"delete_SideTrdRegTimestampType", _wrap_delete_SideTrdRegTimestampType, METH_VARARGS, NULL},
	 { (char *)"SideTrdRegTimestampType_swigregister", SideTrdRegTimestampType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AgreementDate", _wrap_new_AgreementDate, METH_VARARGS, NULL},
	 { (char *)"delete_AgreementDate", _wrap_delete_AgreementDate, METH_VARARGS, NULL},
	 { (char *)"AgreementDate_swigregister", AgreementDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PartySubIDType", _wrap_new_PartySubIDType, METH_VARARGS, NULL},
	 { (char *)"delete_PartySubIDType", _wrap_delete_PartySubIDType, METH_VARARGS, NULL},
	 { (char *)"PartySubIDType_swigregister", PartySubIDType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotalNetValue", _wrap_new_TotalNetValue, METH_VARARGS, NULL},
	 { (char *)"delete_TotalNetValue", _wrap_delete_TotalNetValue, METH_VARARGS, NULL},
	 { (char *)"TotalNetValue_swigregister", TotalNetValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocNoOrdersType", _wrap_new_AllocNoOrdersType, METH_VARARGS, NULL},
	 { (char *)"delete_AllocNoOrdersType", _wrap_delete_AllocNoOrdersType, METH_VARARGS, NULL},
	 { (char *)"AllocNoOrdersType_swigregister", AllocNoOrdersType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocLinkID", _wrap_new_AllocLinkID, METH_VARARGS, NULL},
	 { (char *)"delete_AllocLinkID", _wrap_delete_AllocLinkID, METH_VARARGS, NULL},
	 { (char *)"AllocLinkID_swigregister", AllocLinkID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RoundingModulus", _wrap_new_RoundingModulus, METH_VARARGS, NULL},
	 { (char *)"delete_RoundingModulus", _wrap_delete_RoundingModulus, METH_VARARGS, NULL},
	 { (char *)"RoundingModulus_swigregister", RoundingModulus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OnBehalfOfCompID", _wrap_new_OnBehalfOfCompID, METH_VARARGS, NULL},
	 { (char *)"delete_OnBehalfOfCompID", _wrap_delete_OnBehalfOfCompID, METH_VARARGS, NULL},
	 { (char *)"OnBehalfOfCompID_swigregister", OnBehalfOfCompID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSecurityID", _wrap_new_UnderlyingSecurityID, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSecurityID", _wrap_delete_UnderlyingSecurityID, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSecurityID_swigregister", UnderlyingSecurityID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlObligMsgID", _wrap_new_SettlObligMsgID, METH_VARARGS, NULL},
	 { (char *)"delete_SettlObligMsgID", _wrap_delete_SettlObligMsgID, METH_VARARGS, NULL},
	 { (char *)"SettlObligMsgID_swigregister", SettlObligMsgID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PositionLimit", _wrap_new_PositionLimit, METH_VARARGS, NULL},
	 { (char *)"delete_PositionLimit", _wrap_delete_PositionLimit, METH_VARARGS, NULL},
	 { (char *)"PositionLimit_swigregister", PositionLimit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SharedCommission", _wrap_new_SharedCommission, METH_VARARGS, NULL},
	 { (char *)"delete_SharedCommission", _wrap_delete_SharedCommission, METH_VARARGS, NULL},
	 { (char *)"SharedCommission_swigregister", SharedCommission_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllowableOneSidednessPct", _wrap_new_AllowableOneSidednessPct, METH_VARARGS, NULL},
	 { (char *)"delete_AllowableOneSidednessPct", _wrap_delete_AllowableOneSidednessPct, METH_VARARGS, NULL},
	 { (char *)"AllowableOneSidednessPct_swigregister", AllowableOneSidednessPct_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocText", _wrap_new_AllocText, METH_VARARGS, NULL},
	 { (char *)"delete_AllocText", _wrap_delete_AllocText, METH_VARARGS, NULL},
	 { (char *)"AllocText_swigregister", AllocText_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EndSeqNo", _wrap_new_EndSeqNo, METH_VARARGS, NULL},
	 { (char *)"delete_EndSeqNo", _wrap_delete_EndSeqNo, METH_VARARGS, NULL},
	 { (char *)"EndSeqNo_swigregister", EndSeqNo_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoPartyIDs", _wrap_new_NoPartyIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoPartyIDs", _wrap_delete_NoPartyIDs, METH_VARARGS, NULL},
	 { (char *)"NoPartyIDs_swigregister", NoPartyIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoContraBrokers", _wrap_new_NoContraBrokers, METH_VARARGS, NULL},
	 { (char *)"delete_NoContraBrokers", _wrap_delete_NoContraBrokers, METH_VARARGS, NULL},
	 { (char *)"NoContraBrokers_swigregister", NoContraBrokers_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocLinkType", _wrap_new_AllocLinkType, METH_VARARGS, NULL},
	 { (char *)"delete_AllocLinkType", _wrap_delete_AllocLinkType, METH_VARARGS, NULL},
	 { (char *)"AllocLinkType_swigregister", AllocLinkType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingAllocationPercent", _wrap_new_UnderlyingAllocationPercent, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingAllocationPercent", _wrap_delete_UnderlyingAllocationPercent, METH_VARARGS, NULL},
	 { (char *)"UnderlyingAllocationPercent_swigregister", UnderlyingAllocationPercent_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocAccruedInterestAmt", _wrap_new_AllocAccruedInterestAmt, METH_VARARGS, NULL},
	 { (char *)"delete_AllocAccruedInterestAmt", _wrap_delete_AllocAccruedInterestAmt, METH_VARARGS, NULL},
	 { (char *)"AllocAccruedInterestAmt_swigregister", AllocAccruedInterestAmt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedSecurityListDesc", _wrap_new_EncodedSecurityListDesc, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedSecurityListDesc", _wrap_delete_EncodedSecurityListDesc, METH_VARARGS, NULL},
	 { (char *)"EncodedSecurityListDesc_swigregister", EncodedSecurityListDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncryptedPasswordLen", _wrap_new_EncryptedPasswordLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncryptedPasswordLen", _wrap_delete_EncryptedPasswordLen, METH_VARARGS, NULL},
	 { (char *)"EncryptedPasswordLen_swigregister", EncryptedPasswordLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegDividendYield", _wrap_new_LegDividendYield, METH_VARARGS, NULL},
	 { (char *)"delete_LegDividendYield", _wrap_delete_LegDividendYield, METH_VARARGS, NULL},
	 { (char *)"LegDividendYield_swigregister", LegDividendYield_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefreshIndicator", _wrap_new_RefreshIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_RefreshIndicator", _wrap_delete_RefreshIndicator, METH_VARARGS, NULL},
	 { (char *)"RefreshIndicator_swigregister", RefreshIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideSettlCurrency", _wrap_new_SideSettlCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_SideSettlCurrency", _wrap_delete_SideSettlCurrency, METH_VARARGS, NULL},
	 { (char *)"SideSettlCurrency_swigregister", SideSettlCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSettlementType", _wrap_new_UnderlyingSettlementType, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSettlementType", _wrap_delete_UnderlyingSettlementType, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSettlementType_swigregister", UnderlyingSettlementType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrderCapacityQty", _wrap_new_OrderCapacityQty, METH_VARARGS, NULL},
	 { (char *)"delete_OrderCapacityQty", _wrap_delete_OrderCapacityQty, METH_VARARGS, NULL},
	 { (char *)"OrderCapacityQty_swigregister", OrderCapacityQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LongQty", _wrap_new_LongQty, METH_VARARGS, NULL},
	 { (char *)"delete_LongQty", _wrap_delete_LongQty, METH_VARARGS, NULL},
	 { (char *)"LongQty_swigregister", LongQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSettlMethod", _wrap_new_DerivativeSettlMethod, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSettlMethod", _wrap_delete_DerivativeSettlMethod, METH_VARARGS, NULL},
	 { (char *)"DerivativeSettlMethod_swigregister", DerivativeSettlMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerTradingSessionID", _wrap_new_TriggerTradingSessionID, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerTradingSessionID", _wrap_delete_TriggerTradingSessionID, METH_VARARGS, NULL},
	 { (char *)"TriggerTradingSessionID_swigregister", TriggerTradingSessionID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DisplayMethod", _wrap_new_DisplayMethod, METH_VARARGS, NULL},
	 { (char *)"delete_DisplayMethod", _wrap_delete_DisplayMethod, METH_VARARGS, NULL},
	 { (char *)"DisplayMethod_swigregister", DisplayMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RptSeq", _wrap_new_RptSeq, METH_VARARGS, NULL},
	 { (char *)"delete_RptSeq", _wrap_delete_RptSeq, METH_VARARGS, NULL},
	 { (char *)"RptSeq_swigregister", RptSeq_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDEntryOriginator", _wrap_new_MDEntryOriginator, METH_VARARGS, NULL},
	 { (char *)"delete_MDEntryOriginator", _wrap_delete_MDEntryOriginator, METH_VARARGS, NULL},
	 { (char *)"MDEntryOriginator_swigregister", MDEntryOriginator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegInstrRegistry", _wrap_new_LegInstrRegistry, METH_VARARGS, NULL},
	 { (char *)"delete_LegInstrRegistry", _wrap_delete_LegInstrRegistry, METH_VARARGS, NULL},
	 { (char *)"LegInstrRegistry_swigregister", LegInstrRegistry_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FillQty", _wrap_new_FillQty, METH_VARARGS, NULL},
	 { (char *)"delete_FillQty", _wrap_delete_FillQty, METH_VARARGS, NULL},
	 { (char *)"FillQty_swigregister", FillQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PegSecurityIDSource", _wrap_new_PegSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_PegSecurityIDSource", _wrap_delete_PegSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"PegSecurityIDSource_swigregister", PegSecurityIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaturityTime", _wrap_new_MaturityTime, METH_VARARGS, NULL},
	 { (char *)"delete_MaturityTime", _wrap_delete_MaturityTime, METH_VARARGS, NULL},
	 { (char *)"MaturityTime_swigregister", MaturityTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDFeedType", _wrap_new_MDFeedType, METH_VARARGS, NULL},
	 { (char *)"delete_MDFeedType", _wrap_delete_MDFeedType, METH_VARARGS, NULL},
	 { (char *)"MDFeedType_swigregister", MDFeedType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollStatus", _wrap_new_CollStatus, METH_VARARGS, NULL},
	 { (char *)"delete_CollStatus", _wrap_delete_CollStatus, METH_VARARGS, NULL},
	 { (char *)"CollStatus_swigregister", CollStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSecuritySubType", _wrap_new_UnderlyingSecuritySubType, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSecuritySubType", _wrap_delete_UnderlyingSecuritySubType, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSecuritySubType_swigregister", UnderlyingSecuritySubType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CstmApplVerID", _wrap_new_CstmApplVerID, METH_VARARGS, NULL},
	 { (char *)"delete_CstmApplVerID", _wrap_delete_CstmApplVerID, METH_VARARGS, NULL},
	 { (char *)"CstmApplVerID_swigregister", CstmApplVerID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DefaultApplExtID", _wrap_new_DefaultApplExtID, METH_VARARGS, NULL},
	 { (char *)"delete_DefaultApplExtID", _wrap_delete_DefaultApplExtID, METH_VARARGS, NULL},
	 { (char *)"DefaultApplExtID_swigregister", DefaultApplExtID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoDerivativeSecurityAltID", _wrap_new_NoDerivativeSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"delete_NoDerivativeSecurityAltID", _wrap_delete_NoDerivativeSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"NoDerivativeSecurityAltID_swigregister", NoDerivativeSecurityAltID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideValueInd", _wrap_new_SideValueInd, METH_VARARGS, NULL},
	 { (char *)"delete_SideValueInd", _wrap_delete_SideValueInd, METH_VARARGS, NULL},
	 { (char *)"SideValueInd_swigregister", SideValueInd_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedText", _wrap_new_EncodedText, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedText", _wrap_delete_EncodedText, METH_VARARGS, NULL},
	 { (char *)"EncodedText_swigregister", EncodedText_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Account", _wrap_new_Account, METH_VARARGS, NULL},
	 { (char *)"delete_Account", _wrap_delete_Account, METH_VARARGS, NULL},
	 { (char *)"Account_swigregister", Account_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerNewPrice", _wrap_new_TriggerNewPrice, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerNewPrice", _wrap_delete_TriggerNewPrice, METH_VARARGS, NULL},
	 { (char *)"TriggerNewPrice_swigregister", TriggerNewPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UndlyInstrumentPartyRole", _wrap_new_UndlyInstrumentPartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_UndlyInstrumentPartyRole", _wrap_delete_UndlyInstrumentPartyRole, METH_VARARGS, NULL},
	 { (char *)"UndlyInstrumentPartyRole_swigregister", UndlyInstrumentPartyRole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MsgDirection", _wrap_new_MsgDirection, METH_VARARGS, NULL},
	 { (char *)"delete_MsgDirection", _wrap_delete_MsgDirection, METH_VARARGS, NULL},
	 { (char *)"MsgDirection_swigregister", MsgDirection_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegMaturityDate", _wrap_new_LegMaturityDate, METH_VARARGS, NULL},
	 { (char *)"delete_LegMaturityDate", _wrap_delete_LegMaturityDate, METH_VARARGS, NULL},
	 { (char *)"LegMaturityDate_swigregister", LegMaturityDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingContractMultiplierUnit", _wrap_new_UnderlyingContractMultiplierUnit, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingContractMultiplierUnit", _wrap_delete_UnderlyingContractMultiplierUnit, METH_VARARGS, NULL},
	 { (char *)"UnderlyingContractMultiplierUnit_swigregister", UnderlyingContractMultiplierUnit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InputSource", _wrap_new_InputSource, METH_VARARGS, NULL},
	 { (char *)"delete_InputSource", _wrap_delete_InputSource, METH_VARARGS, NULL},
	 { (char *)"InputSource_swigregister", InputSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDUpdateAction", _wrap_new_MDUpdateAction, METH_VARARGS, NULL},
	 { (char *)"delete_MDUpdateAction", _wrap_delete_MDUpdateAction, METH_VARARGS, NULL},
	 { (char *)"MDUpdateAction_swigregister", MDUpdateAction_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MatchStatus", _wrap_new_MatchStatus, METH_VARARGS, NULL},
	 { (char *)"delete_MatchStatus", _wrap_delete_MatchStatus, METH_VARARGS, NULL},
	 { (char *)"MatchStatus_swigregister", MatchStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RateSource", _wrap_new_RateSource, METH_VARARGS, NULL},
	 { (char *)"delete_RateSource", _wrap_delete_RateSource, METH_VARARGS, NULL},
	 { (char *)"RateSource_swigregister", RateSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocPositionEffect", _wrap_new_AllocPositionEffect, METH_VARARGS, NULL},
	 { (char *)"delete_AllocPositionEffect", _wrap_delete_AllocPositionEffect, METH_VARARGS, NULL},
	 { (char *)"AllocPositionEffect_swigregister", AllocPositionEffect_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PartyIDSource", _wrap_new_PartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_PartyIDSource", _wrap_delete_PartyIDSource, METH_VARARGS, NULL},
	 { (char *)"PartyIDSource_swigregister", PartyIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedUnderlyingIssuer", _wrap_new_EncodedUnderlyingIssuer, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedUnderlyingIssuer", _wrap_delete_EncodedUnderlyingIssuer, METH_VARARGS, NULL},
	 { (char *)"EncodedUnderlyingIssuer_swigregister", EncodedUnderlyingIssuer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncryptedPassword", _wrap_new_EncryptedPassword, METH_VARARGS, NULL},
	 { (char *)"delete_EncryptedPassword", _wrap_delete_EncryptedPassword, METH_VARARGS, NULL},
	 { (char *)"EncryptedPassword_swigregister", EncryptedPassword_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerNewQty", _wrap_new_TriggerNewQty, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerNewQty", _wrap_delete_TriggerNewQty, METH_VARARGS, NULL},
	 { (char *)"TriggerNewQty_swigregister", TriggerNewQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegLastForwardPoints", _wrap_new_LegLastForwardPoints, METH_VARARGS, NULL},
	 { (char *)"delete_LegLastForwardPoints", _wrap_delete_LegLastForwardPoints, METH_VARARGS, NULL},
	 { (char *)"LegLastForwardPoints_swigregister", LegLastForwardPoints_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotNumTradeReports", _wrap_new_TotNumTradeReports, METH_VARARGS, NULL},
	 { (char *)"delete_TotNumTradeReports", _wrap_delete_TotNumTradeReports, METH_VARARGS, NULL},
	 { (char *)"TotNumTradeReports_swigregister", TotNumTradeReports_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefApplVerID", _wrap_new_RefApplVerID, METH_VARARGS, NULL},
	 { (char *)"delete_RefApplVerID", _wrap_delete_RefApplVerID, METH_VARARGS, NULL},
	 { (char *)"RefApplVerID_swigregister", RefApplVerID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastSpotRate", _wrap_new_LastSpotRate, METH_VARARGS, NULL},
	 { (char *)"delete_LastSpotRate", _wrap_delete_LastSpotRate, METH_VARARGS, NULL},
	 { (char *)"LastSpotRate_swigregister", LastSpotRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Price", _wrap_new_Price, METH_VARARGS, NULL},
	 { (char *)"delete_Price", _wrap_delete_Price, METH_VARARGS, NULL},
	 { (char *)"Price_swigregister", Price_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSecurityIDSource", _wrap_new_UnderlyingSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSecurityIDSource", _wrap_delete_UnderlyingSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSecurityIDSource_swigregister", UnderlyingSecurityIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotNoSecurityTypes", _wrap_new_TotNoSecurityTypes, METH_VARARGS, NULL},
	 { (char *)"delete_TotNoSecurityTypes", _wrap_delete_TotNoSecurityTypes, METH_VARARGS, NULL},
	 { (char *)"TotNoSecurityTypes_swigregister", TotNoSecurityTypes_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ReportedPx", _wrap_new_ReportedPx, METH_VARARGS, NULL},
	 { (char *)"delete_ReportedPx", _wrap_delete_ReportedPx, METH_VARARGS, NULL},
	 { (char *)"ReportedPx_swigregister", ReportedPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSymbol", _wrap_new_LegSymbol, METH_VARARGS, NULL},
	 { (char *)"delete_LegSymbol", _wrap_delete_LegSymbol, METH_VARARGS, NULL},
	 { (char *)"LegSymbol_swigregister", LegSymbol_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegIssuer", _wrap_new_LegIssuer, METH_VARARGS, NULL},
	 { (char *)"delete_LegIssuer", _wrap_delete_LegIssuer, METH_VARARGS, NULL},
	 { (char *)"LegIssuer_swigregister", LegIssuer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RegistDetls", _wrap_new_RegistDetls, METH_VARARGS, NULL},
	 { (char *)"delete_RegistDetls", _wrap_delete_RegistDetls, METH_VARARGS, NULL},
	 { (char *)"RegistDetls_swigregister", RegistDetls_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegSecurityID", _wrap_new_UnderlyingLegSecurityID, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegSecurityID", _wrap_delete_UnderlyingLegSecurityID, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegSecurityID_swigregister", UnderlyingLegSecurityID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MinLotSize", _wrap_new_MinLotSize, METH_VARARGS, NULL},
	 { (char *)"delete_MinLotSize", _wrap_delete_MinLotSize, METH_VARARGS, NULL},
	 { (char *)"MinLotSize_swigregister", MinLotSize_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NumTickets", _wrap_new_NumTickets, METH_VARARGS, NULL},
	 { (char *)"delete_NumTickets", _wrap_delete_NumTickets, METH_VARARGS, NULL},
	 { (char *)"NumTickets_swigregister", NumTickets_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegLocaleOfIssue", _wrap_new_LegLocaleOfIssue, METH_VARARGS, NULL},
	 { (char *)"delete_LegLocaleOfIssue", _wrap_delete_LegLocaleOfIssue, METH_VARARGS, NULL},
	 { (char *)"LegLocaleOfIssue_swigregister", LegLocaleOfIssue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExchangeForPhysical", _wrap_new_ExchangeForPhysical, METH_VARARGS, NULL},
	 { (char *)"delete_ExchangeForPhysical", _wrap_delete_ExchangeForPhysical, METH_VARARGS, NULL},
	 { (char *)"ExchangeForPhysical_swigregister", ExchangeForPhysical_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityTradingEvent", _wrap_new_SecurityTradingEvent, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityTradingEvent", _wrap_delete_SecurityTradingEvent, METH_VARARGS, NULL},
	 { (char *)"SecurityTradingEvent_swigregister", SecurityTradingEvent_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MinPriceIncrementAmount", _wrap_new_MinPriceIncrementAmount, METH_VARARGS, NULL},
	 { (char *)"delete_MinPriceIncrementAmount", _wrap_delete_MinPriceIncrementAmount, METH_VARARGS, NULL},
	 { (char *)"MinPriceIncrementAmount_swigregister", MinPriceIncrementAmount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingPayAmount", _wrap_new_UnderlyingPayAmount, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingPayAmount", _wrap_delete_UnderlyingPayAmount, METH_VARARGS, NULL},
	 { (char *)"UnderlyingPayAmount_swigregister", UnderlyingPayAmount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlPartySubID", _wrap_new_SettlPartySubID, METH_VARARGS, NULL},
	 { (char *)"delete_SettlPartySubID", _wrap_delete_SettlPartySubID, METH_VARARGS, NULL},
	 { (char *)"SettlPartySubID_swigregister", SettlPartySubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocNetMoney", _wrap_new_AllocNetMoney, METH_VARARGS, NULL},
	 { (char *)"delete_AllocNetMoney", _wrap_delete_AllocNetMoney, METH_VARARGS, NULL},
	 { (char *)"AllocNetMoney_swigregister", AllocNetMoney_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingMaturityDay", _wrap_new_UnderlyingMaturityDay, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingMaturityDay", _wrap_delete_UnderlyingMaturityDay, METH_VARARGS, NULL},
	 { (char *)"UnderlyingMaturityDay_swigregister", UnderlyingMaturityDay_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NetworkResponseID", _wrap_new_NetworkResponseID, METH_VARARGS, NULL},
	 { (char *)"delete_NetworkResponseID", _wrap_delete_NetworkResponseID, METH_VARARGS, NULL},
	 { (char *)"NetworkResponseID_swigregister", NetworkResponseID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NumBidders", _wrap_new_NumBidders, METH_VARARGS, NULL},
	 { (char *)"delete_NumBidders", _wrap_delete_NumBidders, METH_VARARGS, NULL},
	 { (char *)"NumBidders_swigregister", NumBidders_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocAcctIDSource", _wrap_new_AllocAcctIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_AllocAcctIDSource", _wrap_delete_AllocAcctIDSource, METH_VARARGS, NULL},
	 { (char *)"AllocAcctIDSource_swigregister", AllocAcctIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocAvgPx", _wrap_new_AllocAvgPx, METH_VARARGS, NULL},
	 { (char *)"delete_AllocAvgPx", _wrap_delete_AllocAvgPx, METH_VARARGS, NULL},
	 { (char *)"AllocAvgPx_swigregister", AllocAvgPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecuritySettlAgentCode", _wrap_new_SecuritySettlAgentCode, METH_VARARGS, NULL},
	 { (char *)"delete_SecuritySettlAgentCode", _wrap_delete_SecuritySettlAgentCode, METH_VARARGS, NULL},
	 { (char *)"SecuritySettlAgentCode_swigregister", SecuritySettlAgentCode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoDistribInsts", _wrap_new_NoDistribInsts, METH_VARARGS, NULL},
	 { (char *)"delete_NoDistribInsts", _wrap_delete_NoDistribInsts, METH_VARARGS, NULL},
	 { (char *)"NoDistribInsts_swigregister", NoDistribInsts_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CustDirectedOrder", _wrap_new_CustDirectedOrder, METH_VARARGS, NULL},
	 { (char *)"delete_CustDirectedOrder", _wrap_delete_CustDirectedOrder, METH_VARARGS, NULL},
	 { (char *)"CustDirectedOrder_swigregister", CustDirectedOrder_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FairValue", _wrap_new_FairValue, METH_VARARGS, NULL},
	 { (char *)"delete_FairValue", _wrap_delete_FairValue, METH_VARARGS, NULL},
	 { (char *)"FairValue_swigregister", FairValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoStrikes", _wrap_new_NoStrikes, METH_VARARGS, NULL},
	 { (char *)"delete_NoStrikes", _wrap_delete_NoStrikes, METH_VARARGS, NULL},
	 { (char *)"NoStrikes_swigregister", NoStrikes_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedSecurityListDescLen", _wrap_new_EncodedSecurityListDescLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedSecurityListDescLen", _wrap_delete_EncodedSecurityListDescLen, METH_VARARGS, NULL},
	 { (char *)"EncodedSecurityListDescLen_swigregister", EncodedSecurityListDescLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegExerciseStyle", _wrap_new_LegExerciseStyle, METH_VARARGS, NULL},
	 { (char *)"delete_LegExerciseStyle", _wrap_delete_LegExerciseStyle, METH_VARARGS, NULL},
	 { (char *)"LegExerciseStyle_swigregister", LegExerciseStyle_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSymbolSfx", _wrap_new_DerivativeSymbolSfx, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSymbolSfx", _wrap_delete_DerivativeSymbolSfx, METH_VARARGS, NULL},
	 { (char *)"DerivativeSymbolSfx_swigregister", DerivativeSymbolSfx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NestedInstrAttribType", _wrap_new_NestedInstrAttribType, METH_VARARGS, NULL},
	 { (char *)"delete_NestedInstrAttribType", _wrap_delete_NestedInstrAttribType, METH_VARARGS, NULL},
	 { (char *)"NestedInstrAttribType_swigregister", NestedInstrAttribType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ContraTrader", _wrap_new_ContraTrader, METH_VARARGS, NULL},
	 { (char *)"delete_ContraTrader", _wrap_delete_ContraTrader, METH_VARARGS, NULL},
	 { (char *)"ContraTrader_swigregister", ContraTrader_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDSecSize", _wrap_new_MDSecSize, METH_VARARGS, NULL},
	 { (char *)"delete_MDSecSize", _wrap_delete_MDSecSize, METH_VARARGS, NULL},
	 { (char *)"MDSecSize_swigregister", MDSecSize_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoOfSecSizes", _wrap_new_NoOfSecSizes, METH_VARARGS, NULL},
	 { (char *)"delete_NoOfSecSizes", _wrap_delete_NoOfSecSizes, METH_VARARGS, NULL},
	 { (char *)"NoOfSecSizes_swigregister", NoOfSecSizes_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollAction", _wrap_new_CollAction, METH_VARARGS, NULL},
	 { (char *)"delete_CollAction", _wrap_delete_CollAction, METH_VARARGS, NULL},
	 { (char *)"CollAction_swigregister", CollAction_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLastQty", _wrap_new_UnderlyingLastQty, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLastQty", _wrap_delete_UnderlyingLastQty, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLastQty_swigregister", UnderlyingLastQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PossDupFlag", _wrap_new_PossDupFlag, METH_VARARGS, NULL},
	 { (char *)"delete_PossDupFlag", _wrap_delete_PossDupFlag, METH_VARARGS, NULL},
	 { (char *)"PossDupFlag_swigregister", PossDupFlag_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ListStatusType", _wrap_new_ListStatusType, METH_VARARGS, NULL},
	 { (char *)"delete_ListStatusType", _wrap_delete_ListStatusType, METH_VARARGS, NULL},
	 { (char *)"ListStatusType_swigregister", ListStatusType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SideFillStationCd", _wrap_new_SideFillStationCd, METH_VARARGS, NULL},
	 { (char *)"delete_SideFillStationCd", _wrap_delete_SideFillStationCd, METH_VARARGS, NULL},
	 { (char *)"SideFillStationCd_swigregister", SideFillStationCd_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StatusText", _wrap_new_StatusText, METH_VARARGS, NULL},
	 { (char *)"delete_StatusText", _wrap_delete_StatusText, METH_VARARGS, NULL},
	 { (char *)"StatusText_swigregister", StatusText_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BasisFeatureDate", _wrap_new_BasisFeatureDate, METH_VARARGS, NULL},
	 { (char *)"delete_BasisFeatureDate", _wrap_delete_BasisFeatureDate, METH_VARARGS, NULL},
	 { (char *)"BasisFeatureDate_swigregister", BasisFeatureDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_XmlDataLen", _wrap_new_XmlDataLen, METH_VARARGS, NULL},
	 { (char *)"delete_XmlDataLen", _wrap_delete_XmlDataLen, METH_VARARGS, NULL},
	 { (char *)"XmlDataLen_swigregister", XmlDataLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingMaturityDate", _wrap_new_UnderlyingMaturityDate, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingMaturityDate", _wrap_delete_UnderlyingMaturityDate, METH_VARARGS, NULL},
	 { (char *)"UnderlyingMaturityDate_swigregister", UnderlyingMaturityDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_GapFillFlag", _wrap_new_GapFillFlag, METH_VARARGS, NULL},
	 { (char *)"delete_GapFillFlag", _wrap_delete_GapFillFlag, METH_VARARGS, NULL},
	 { (char *)"GapFillFlag_swigregister", GapFillFlag_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefApplExtID", _wrap_new_RefApplExtID, METH_VARARGS, NULL},
	 { (char *)"delete_RefApplExtID", _wrap_delete_RefApplExtID, METH_VARARGS, NULL},
	 { (char *)"RefApplExtID_swigregister", RefApplExtID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefApplID", _wrap_new_RefApplID, METH_VARARGS, NULL},
	 { (char *)"delete_RefApplID", _wrap_delete_RefApplID, METH_VARARGS, NULL},
	 { (char *)"RefApplID_swigregister", RefApplID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoTradingSessionRules", _wrap_new_NoTradingSessionRules, METH_VARARGS, NULL},
	 { (char *)"delete_NoTradingSessionRules", _wrap_delete_NoTradingSessionRules, METH_VARARGS, NULL},
	 { (char *)"NoTradingSessionRules_swigregister", NoTradingSessionRules_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SwapPoints", _wrap_new_SwapPoints, METH_VARARGS, NULL},
	 { (char *)"delete_SwapPoints", _wrap_delete_SwapPoints, METH_VARARGS, NULL},
	 { (char *)"SwapPoints_swigregister", SwapPoints_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TargetStrategyParameters", _wrap_new_TargetStrategyParameters, METH_VARARGS, NULL},
	 { (char *)"delete_TargetStrategyParameters", _wrap_delete_TargetStrategyParameters, METH_VARARGS, NULL},
	 { (char *)"TargetStrategyParameters_swigregister", TargetStrategyParameters_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastForwardPoints", _wrap_new_LastForwardPoints, METH_VARARGS, NULL},
	 { (char *)"delete_LastForwardPoints", _wrap_delete_LastForwardPoints, METH_VARARGS, NULL},
	 { (char *)"LastForwardPoints_swigregister", LastForwardPoints_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_YieldRedemptionDate", _wrap_new_YieldRedemptionDate, METH_VARARGS, NULL},
	 { (char *)"delete_YieldRedemptionDate", _wrap_delete_YieldRedemptionDate, METH_VARARGS, NULL},
	 { (char *)"YieldRedemptionDate_swigregister", YieldRedemptionDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoSettlDetails", _wrap_new_NoSettlDetails, METH_VARARGS, NULL},
	 { (char *)"delete_NoSettlDetails", _wrap_delete_NoSettlDetails, METH_VARARGS, NULL},
	 { (char *)"NoSettlDetails_swigregister", NoSettlDetails_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeHandlingInstr", _wrap_new_TradeHandlingInstr, METH_VARARGS, NULL},
	 { (char *)"delete_TradeHandlingInstr", _wrap_delete_TradeHandlingInstr, METH_VARARGS, NULL},
	 { (char *)"TradeHandlingInstr_swigregister", TradeHandlingInstr_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashSettlAgentCode", _wrap_new_CashSettlAgentCode, METH_VARARGS, NULL},
	 { (char *)"delete_CashSettlAgentCode", _wrap_delete_CashSettlAgentCode, METH_VARARGS, NULL},
	 { (char *)"CashSettlAgentCode_swigregister", CashSettlAgentCode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegPriceType", _wrap_new_LegPriceType, METH_VARARGS, NULL},
	 { (char *)"delete_LegPriceType", _wrap_delete_LegPriceType, METH_VARARGS, NULL},
	 { (char *)"LegPriceType_swigregister", LegPriceType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedListExecInstLen", _wrap_new_EncodedListExecInstLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedListExecInstLen", _wrap_delete_EncodedListExecInstLen, METH_VARARGS, NULL},
	 { (char *)"EncodedListExecInstLen_swigregister", EncodedListExecInstLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradSesMethod", _wrap_new_TradSesMethod, METH_VARARGS, NULL},
	 { (char *)"delete_TradSesMethod", _wrap_delete_TradSesMethod, METH_VARARGS, NULL},
	 { (char *)"TradSesMethod_swigregister", TradSesMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AgreementID", _wrap_new_AgreementID, METH_VARARGS, NULL},
	 { (char *)"delete_AgreementID", _wrap_delete_AgreementID, METH_VARARGS, NULL},
	 { (char *)"AgreementID_swigregister", AgreementID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashDistribCurr", _wrap_new_CashDistribCurr, METH_VARARGS, NULL},
	 { (char *)"delete_CashDistribCurr", _wrap_delete_CashDistribCurr, METH_VARARGS, NULL},
	 { (char *)"CashDistribCurr_swigregister", CashDistribCurr_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BidPx", _wrap_new_BidPx, METH_VARARGS, NULL},
	 { (char *)"delete_BidPx", _wrap_delete_BidPx, METH_VARARGS, NULL},
	 { (char *)"BidPx_swigregister", BidPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeType", _wrap_new_TradeType, METH_VARARGS, NULL},
	 { (char *)"delete_TradeType", _wrap_delete_TradeType, METH_VARARGS, NULL},
	 { (char *)"TradeType_swigregister", TradeType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedSecurityDescLen", _wrap_new_EncodedSecurityDescLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedSecurityDescLen", _wrap_delete_EncodedSecurityDescLen, METH_VARARGS, NULL},
	 { (char *)"EncodedSecurityDescLen_swigregister", EncodedSecurityDescLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ComplexEventCondition", _wrap_new_ComplexEventCondition, METH_VARARGS, NULL},
	 { (char *)"delete_ComplexEventCondition", _wrap_delete_ComplexEventCondition, METH_VARARGS, NULL},
	 { (char *)"ComplexEventCondition_swigregister", ComplexEventCondition_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncryptedPasswordMethod", _wrap_new_EncryptedPasswordMethod, METH_VARARGS, NULL},
	 { (char *)"delete_EncryptedPasswordMethod", _wrap_delete_EncryptedPasswordMethod, METH_VARARGS, NULL},
	 { (char *)"EncryptedPasswordMethod_swigregister", EncryptedPasswordMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSecurityAltID", _wrap_new_DerivativeSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSecurityAltID", _wrap_delete_DerivativeSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"DerivativeSecurityAltID_swigregister", DerivativeSecurityAltID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotNoAccQuotes", _wrap_new_TotNoAccQuotes, METH_VARARGS, NULL},
	 { (char *)"delete_TotNoAccQuotes", _wrap_delete_TotNoAccQuotes, METH_VARARGS, NULL},
	 { (char *)"TotNoAccQuotes_swigregister", TotNoAccQuotes_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TimeBracket", _wrap_new_TimeBracket, METH_VARARGS, NULL},
	 { (char *)"delete_TimeBracket", _wrap_delete_TimeBracket, METH_VARARGS, NULL},
	 { (char *)"TimeBracket_swigregister", TimeBracket_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoAllocs", _wrap_new_NoAllocs, METH_VARARGS, NULL},
	 { (char *)"delete_NoAllocs", _wrap_delete_NoAllocs, METH_VARARGS, NULL},
	 { (char *)"NoAllocs_swigregister", NoAllocs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingProduct", _wrap_new_UnderlyingProduct, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingProduct", _wrap_delete_UnderlyingProduct, METH_VARARGS, NULL},
	 { (char *)"UnderlyingProduct_swigregister", UnderlyingProduct_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BenchmarkCurveName", _wrap_new_BenchmarkCurveName, METH_VARARGS, NULL},
	 { (char *)"delete_BenchmarkCurveName", _wrap_delete_BenchmarkCurveName, METH_VARARGS, NULL},
	 { (char *)"BenchmarkCurveName_swigregister", BenchmarkCurveName_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSymbolSfx", _wrap_new_UnderlyingSymbolSfx, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSymbolSfx", _wrap_delete_UnderlyingSymbolSfx, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSymbolSfx_swigregister", UnderlyingSymbolSfx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StrikePriceBoundaryPrecision", _wrap_new_StrikePriceBoundaryPrecision, METH_VARARGS, NULL},
	 { (char *)"delete_StrikePriceBoundaryPrecision", _wrap_delete_StrikePriceBoundaryPrecision, METH_VARARGS, NULL},
	 { (char *)"StrikePriceBoundaryPrecision_swigregister", StrikePriceBoundaryPrecision_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteSetID", _wrap_new_QuoteSetID, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteSetID", _wrap_delete_QuoteSetID, METH_VARARGS, NULL},
	 { (char *)"QuoteSetID_swigregister", QuoteSetID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashMargin", _wrap_new_CashMargin, METH_VARARGS, NULL},
	 { (char *)"delete_CashMargin", _wrap_delete_CashMargin, METH_VARARGS, NULL},
	 { (char *)"CashMargin_swigregister", CashMargin_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlObligTransType", _wrap_new_SettlObligTransType, METH_VARARGS, NULL},
	 { (char *)"delete_SettlObligTransType", _wrap_delete_SettlObligTransType, METH_VARARGS, NULL},
	 { (char *)"SettlObligTransType_swigregister", SettlObligTransType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegNumber", _wrap_new_LegNumber, METH_VARARGS, NULL},
	 { (char *)"delete_LegNumber", _wrap_delete_LegNumber, METH_VARARGS, NULL},
	 { (char *)"LegNumber_swigregister", LegNumber_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DeskOrderHandlingInst", _wrap_new_DeskOrderHandlingInst, METH_VARARGS, NULL},
	 { (char *)"delete_DeskOrderHandlingInst", _wrap_delete_DeskOrderHandlingInst, METH_VARARGS, NULL},
	 { (char *)"DeskOrderHandlingInst_swigregister", DeskOrderHandlingInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlPartyIDSource", _wrap_new_SettlPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_SettlPartyIDSource", _wrap_delete_SettlPartyIDSource, METH_VARARGS, NULL},
	 { (char *)"SettlPartyIDSource_swigregister", SettlPartyIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PriorSettlPrice", _wrap_new_PriorSettlPrice, METH_VARARGS, NULL},
	 { (char *)"delete_PriorSettlPrice", _wrap_delete_PriorSettlPrice, METH_VARARGS, NULL},
	 { (char *)"PriorSettlPrice_swigregister", PriorSettlPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NotAffOrigClOrdID", _wrap_new_NotAffOrigClOrdID, METH_VARARGS, NULL},
	 { (char *)"delete_NotAffOrigClOrdID", _wrap_delete_NotAffOrigClOrdID, METH_VARARGS, NULL},
	 { (char *)"NotAffOrigClOrdID_swigregister", NotAffOrigClOrdID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradingSessionDesc", _wrap_new_TradingSessionDesc, METH_VARARGS, NULL},
	 { (char *)"delete_TradingSessionDesc", _wrap_delete_TradingSessionDesc, METH_VARARGS, NULL},
	 { (char *)"TradingSessionDesc_swigregister", TradingSessionDesc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeFloorPrice", _wrap_new_DerivativeFloorPrice, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeFloorPrice", _wrap_delete_DerivativeFloorPrice, METH_VARARGS, NULL},
	 { (char *)"DerivativeFloorPrice_swigregister", DerivativeFloorPrice_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSymbol", _wrap_new_DerivativeSymbol, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSymbol", _wrap_delete_DerivativeSymbol, METH_VARARGS, NULL},
	 { (char *)"DerivativeSymbol_swigregister", DerivativeSymbol_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RiskFreeRate", _wrap_new_RiskFreeRate, METH_VARARGS, NULL},
	 { (char *)"delete_RiskFreeRate", _wrap_delete_RiskFreeRate, METH_VARARGS, NULL},
	 { (char *)"RiskFreeRate_swigregister", RiskFreeRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PosTransType", _wrap_new_PosTransType, METH_VARARGS, NULL},
	 { (char *)"delete_PosTransType", _wrap_delete_PosTransType, METH_VARARGS, NULL},
	 { (char *)"PosTransType_swigregister", PosTransType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MsgSeqNum", _wrap_new_MsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"delete_MsgSeqNum", _wrap_delete_MsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MsgSeqNum_swigregister", MsgSeqNum_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Signature", _wrap_new_Signature, METH_VARARGS, NULL},
	 { (char *)"delete_Signature", _wrap_delete_Signature, METH_VARARGS, NULL},
	 { (char *)"Signature_swigregister", Signature_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Seniority", _wrap_new_Seniority, METH_VARARGS, NULL},
	 { (char *)"delete_Seniority", _wrap_delete_Seniority, METH_VARARGS, NULL},
	 { (char *)"Seniority_swigregister", Seniority_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoRateSources", _wrap_new_NoRateSources, METH_VARARGS, NULL},
	 { (char *)"delete_NoRateSources", _wrap_delete_NoRateSources, METH_VARARGS, NULL},
	 { (char *)"NoRateSources_swigregister", NoRateSources_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PriceUnitOfMeasureQty", _wrap_new_PriceUnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"delete_PriceUnitOfMeasureQty", _wrap_delete_PriceUnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"PriceUnitOfMeasureQty_swigregister", PriceUnitOfMeasureQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollAsgnRefID", _wrap_new_CollAsgnRefID, METH_VARARGS, NULL},
	 { (char *)"delete_CollAsgnRefID", _wrap_delete_CollAsgnRefID, METH_VARARGS, NULL},
	 { (char *)"CollAsgnRefID_swigregister", CollAsgnRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BuyVolume", _wrap_new_BuyVolume, METH_VARARGS, NULL},
	 { (char *)"delete_BuyVolume", _wrap_delete_BuyVolume, METH_VARARGS, NULL},
	 { (char *)"BuyVolume_swigregister", BuyVolume_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlCurrFxRateCalc", _wrap_new_SettlCurrFxRateCalc, METH_VARARGS, NULL},
	 { (char *)"delete_SettlCurrFxRateCalc", _wrap_delete_SettlCurrFxRateCalc, METH_VARARGS, NULL},
	 { (char *)"SettlCurrFxRateCalc_swigregister", SettlCurrFxRateCalc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PosMaintStatus", _wrap_new_PosMaintStatus, METH_VARARGS, NULL},
	 { (char *)"delete_PosMaintStatus", _wrap_delete_PosMaintStatus, METH_VARARGS, NULL},
	 { (char *)"PosMaintStatus_swigregister", PosMaintStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PriorSpreadIndicator", _wrap_new_PriorSpreadIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_PriorSpreadIndicator", _wrap_delete_PriorSpreadIndicator, METH_VARARGS, NULL},
	 { (char *)"PriorSpreadIndicator_swigregister", PriorSpreadIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Benchmark", _wrap_new_Benchmark, METH_VARARGS, NULL},
	 { (char *)"delete_Benchmark", _wrap_delete_Benchmark, METH_VARARGS, NULL},
	 { (char *)"Benchmark_swigregister", Benchmark_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaturityMonthYearFormat", _wrap_new_MaturityMonthYearFormat, METH_VARARGS, NULL},
	 { (char *)"delete_MaturityMonthYearFormat", _wrap_delete_MaturityMonthYearFormat, METH_VARARGS, NULL},
	 { (char *)"MaturityMonthYearFormat_swigregister", MaturityMonthYearFormat_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingTradingSessionID", _wrap_new_UnderlyingTradingSessionID, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingTradingSessionID", _wrap_delete_UnderlyingTradingSessionID, METH_VARARGS, NULL},
	 { (char *)"UnderlyingTradingSessionID_swigregister", UnderlyingTradingSessionID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotNoRelatedSym", _wrap_new_TotNoRelatedSym, METH_VARARGS, NULL},
	 { (char *)"delete_TotNoRelatedSym", _wrap_delete_TotNoRelatedSym, METH_VARARGS, NULL},
	 { (char *)"TotNoRelatedSym_swigregister", TotNoRelatedSym_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StateOrProvinceOfIssue", _wrap_new_StateOrProvinceOfIssue, METH_VARARGS, NULL},
	 { (char *)"delete_StateOrProvinceOfIssue", _wrap_delete_StateOrProvinceOfIssue, METH_VARARGS, NULL},
	 { (char *)"StateOrProvinceOfIssue_swigregister", StateOrProvinceOfIssue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeInstrRegistry", _wrap_new_DerivativeInstrRegistry, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeInstrRegistry", _wrap_delete_DerivativeInstrRegistry, METH_VARARGS, NULL},
	 { (char *)"DerivativeInstrRegistry_swigregister", DerivativeInstrRegistry_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegBidForwardPoints", _wrap_new_LegBidForwardPoints, METH_VARARGS, NULL},
	 { (char *)"delete_LegBidForwardPoints", _wrap_delete_LegBidForwardPoints, METH_VARARGS, NULL},
	 { (char *)"LegBidForwardPoints_swigregister", LegBidForwardPoints_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ManualOrderIndicator", _wrap_new_ManualOrderIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_ManualOrderIndicator", _wrap_delete_ManualOrderIndicator, METH_VARARGS, NULL},
	 { (char *)"ManualOrderIndicator_swigregister", ManualOrderIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NetMoney", _wrap_new_NetMoney, METH_VARARGS, NULL},
	 { (char *)"delete_NetMoney", _wrap_delete_NetMoney, METH_VARARGS, NULL},
	 { (char *)"NetMoney_swigregister", NetMoney_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegalConfirm", _wrap_new_LegalConfirm, METH_VARARGS, NULL},
	 { (char *)"delete_LegalConfirm", _wrap_delete_LegalConfirm, METH_VARARGS, NULL},
	 { (char *)"LegalConfirm_swigregister", LegalConfirm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CountryOfIssue", _wrap_new_CountryOfIssue, METH_VARARGS, NULL},
	 { (char *)"delete_CountryOfIssue", _wrap_delete_CountryOfIssue, METH_VARARGS, NULL},
	 { (char *)"CountryOfIssue_swigregister", CountryOfIssue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplReportType", _wrap_new_ApplReportType, METH_VARARGS, NULL},
	 { (char *)"delete_ApplReportType", _wrap_delete_ApplReportType, METH_VARARGS, NULL},
	 { (char *)"ApplReportType_swigregister", ApplReportType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RootPartyID", _wrap_new_RootPartyID, METH_VARARGS, NULL},
	 { (char *)"delete_RootPartyID", _wrap_delete_RootPartyID, METH_VARARGS, NULL},
	 { (char *)"RootPartyID_swigregister", RootPartyID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingQty", _wrap_new_UnderlyingQty, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingQty", _wrap_delete_UnderlyingQty, METH_VARARGS, NULL},
	 { (char *)"UnderlyingQty_swigregister", UnderlyingQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplQueueDepth", _wrap_new_ApplQueueDepth, METH_VARARGS, NULL},
	 { (char *)"delete_ApplQueueDepth", _wrap_delete_ApplQueueDepth, METH_VARARGS, NULL},
	 { (char *)"ApplQueueDepth_swigregister", ApplQueueDepth_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StopPx", _wrap_new_StopPx, METH_VARARGS, NULL},
	 { (char *)"delete_StopPx", _wrap_delete_StopPx, METH_VARARGS, NULL},
	 { (char *)"StopPx_swigregister", StopPx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ReportToExch", _wrap_new_ReportToExch, METH_VARARGS, NULL},
	 { (char *)"delete_ReportToExch", _wrap_delete_ReportToExch, METH_VARARGS, NULL},
	 { (char *)"ReportToExch_swigregister", ReportToExch_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ContraryInstructionIndicator", _wrap_new_ContraryInstructionIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_ContraryInstructionIndicator", _wrap_delete_ContraryInstructionIndicator, METH_VARARGS, NULL},
	 { (char *)"ContraryInstructionIndicator_swigregister", ContraryInstructionIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedListStatusTextLen", _wrap_new_EncodedListStatusTextLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedListStatusTextLen", _wrap_delete_EncodedListStatusTextLen, METH_VARARGS, NULL},
	 { (char *)"EncodedListStatusTextLen_swigregister", EncodedListStatusTextLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSecurityXMLSchema", _wrap_new_DerivativeSecurityXMLSchema, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSecurityXMLSchema", _wrap_delete_DerivativeSecurityXMLSchema, METH_VARARGS, NULL},
	 { (char *)"DerivativeSecurityXMLSchema_swigregister", DerivativeSecurityXMLSchema_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoRelatedSym", _wrap_new_NoRelatedSym, METH_VARARGS, NULL},
	 { (char *)"delete_NoRelatedSym", _wrap_delete_NoRelatedSym, METH_VARARGS, NULL},
	 { (char *)"NoRelatedSym_swigregister", NoRelatedSym_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocRejCode", _wrap_new_AllocRejCode, METH_VARARGS, NULL},
	 { (char *)"delete_AllocRejCode", _wrap_delete_AllocRejCode, METH_VARARGS, NULL},
	 { (char *)"AllocRejCode_swigregister", AllocRejCode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSecurityAltID", _wrap_new_UnderlyingSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSecurityAltID", _wrap_delete_UnderlyingSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSecurityAltID_swigregister", UnderlyingSecurityAltID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefOrdIDReason", _wrap_new_RefOrdIDReason, METH_VARARGS, NULL},
	 { (char *)"delete_RefOrdIDReason", _wrap_delete_RefOrdIDReason, METH_VARARGS, NULL},
	 { (char *)"RefOrdIDReason_swigregister", RefOrdIDReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeInstrumentPartyID", _wrap_new_DerivativeInstrumentPartyID, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeInstrumentPartyID", _wrap_delete_DerivativeInstrumentPartyID, METH_VARARGS, NULL},
	 { (char *)"DerivativeInstrumentPartyID_swigregister", DerivativeInstrumentPartyID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityXMLSchema", _wrap_new_SecurityXMLSchema, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityXMLSchema", _wrap_delete_SecurityXMLSchema, METH_VARARGS, NULL},
	 { (char *)"SecurityXMLSchema_swigregister", SecurityXMLSchema_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefOrderIDSource", _wrap_new_RefOrderIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_RefOrderIDSource", _wrap_delete_RefOrderIDSource, METH_VARARGS, NULL},
	 { (char *)"RefOrderIDSource_swigregister", RefOrderIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NTPositionLimit", _wrap_new_NTPositionLimit, METH_VARARGS, NULL},
	 { (char *)"delete_NTPositionLimit", _wrap_delete_NTPositionLimit, METH_VARARGS, NULL},
	 { (char *)"NTPositionLimit_swigregister", NTPositionLimit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EndAccruedInterestAmt", _wrap_new_EndAccruedInterestAmt, METH_VARARGS, NULL},
	 { (char *)"delete_EndAccruedInterestAmt", _wrap_delete_EndAccruedInterestAmt, METH_VARARGS, NULL},
	 { (char *)"EndAccruedInterestAmt_swigregister", EndAccruedInterestAmt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AccruedInterestRate", _wrap_new_AccruedInterestRate, METH_VARARGS, NULL},
	 { (char *)"delete_AccruedInterestRate", _wrap_delete_AccruedInterestRate, METH_VARARGS, NULL},
	 { (char *)"AccruedInterestRate_swigregister", AccruedInterestRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastCapacity", _wrap_new_LastCapacity, METH_VARARGS, NULL},
	 { (char *)"delete_LastCapacity", _wrap_delete_LastCapacity, METH_VARARGS, NULL},
	 { (char *)"LastCapacity_swigregister", LastCapacity_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingInstrumentPartySubID", _wrap_new_UnderlyingInstrumentPartySubID, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingInstrumentPartySubID", _wrap_delete_UnderlyingInstrumentPartySubID, METH_VARARGS, NULL},
	 { (char *)"UnderlyingInstrumentPartySubID_swigregister", UnderlyingInstrumentPartySubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoFills", _wrap_new_NoFills, METH_VARARGS, NULL},
	 { (char *)"delete_NoFills", _wrap_delete_NoFills, METH_VARARGS, NULL},
	 { (char *)"NoFills_swigregister", NoFills_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoOrdTypeRules", _wrap_new_NoOrdTypeRules, METH_VARARGS, NULL},
	 { (char *)"delete_NoOrdTypeRules", _wrap_delete_NoOrdTypeRules, METH_VARARGS, NULL},
	 { (char *)"NoOrdTypeRules_swigregister", NoOrdTypeRules_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InstrumentPartyID", _wrap_new_InstrumentPartyID, METH_VARARGS, NULL},
	 { (char *)"delete_InstrumentPartyID", _wrap_delete_InstrumentPartyID, METH_VARARGS, NULL},
	 { (char *)"InstrumentPartyID_swigregister", InstrumentPartyID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MarginRatio", _wrap_new_MarginRatio, METH_VARARGS, NULL},
	 { (char *)"delete_MarginRatio", _wrap_delete_MarginRatio, METH_VARARGS, NULL},
	 { (char *)"MarginRatio_swigregister", MarginRatio_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RefTagID", _wrap_new_RefTagID, METH_VARARGS, NULL},
	 { (char *)"delete_RefTagID", _wrap_delete_RefTagID, METH_VARARGS, NULL},
	 { (char *)"RefTagID_swigregister", RefTagID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoRoutingIDs", _wrap_new_NoRoutingIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoRoutingIDs", _wrap_delete_NoRoutingIDs, METH_VARARGS, NULL},
	 { (char *)"NoRoutingIDs_swigregister", NoRoutingIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CouponRate", _wrap_new_CouponRate, METH_VARARGS, NULL},
	 { (char *)"delete_CouponRate", _wrap_delete_CouponRate, METH_VARARGS, NULL},
	 { (char *)"CouponRate_swigregister", CouponRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoApplIDs", _wrap_new_NoApplIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoApplIDs", _wrap_delete_NoApplIDs, METH_VARARGS, NULL},
	 { (char *)"NoApplIDs_swigregister", NoApplIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeContractSettlMonth", _wrap_new_DerivativeContractSettlMonth, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeContractSettlMonth", _wrap_delete_DerivativeContractSettlMonth, METH_VARARGS, NULL},
	 { (char *)"DerivativeContractSettlMonth_swigregister", DerivativeContractSettlMonth_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InstrAttribType", _wrap_new_InstrAttribType, METH_VARARGS, NULL},
	 { (char *)"delete_InstrAttribType", _wrap_delete_InstrAttribType, METH_VARARGS, NULL},
	 { (char *)"InstrAttribType_swigregister", InstrAttribType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Product", _wrap_new_Product, METH_VARARGS, NULL},
	 { (char *)"delete_Product", _wrap_delete_Product, METH_VARARGS, NULL},
	 { (char *)"Product_swigregister", Product_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocShares", _wrap_new_AllocShares, METH_VARARGS, NULL},
	 { (char *)"delete_AllocShares", _wrap_delete_AllocShares, METH_VARARGS, NULL},
	 { (char *)"AllocShares_swigregister", AllocShares_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoQuoteEntries", _wrap_new_NoQuoteEntries, METH_VARARGS, NULL},
	 { (char *)"delete_NoQuoteEntries", _wrap_delete_NoQuoteEntries, METH_VARARGS, NULL},
	 { (char *)"NoQuoteEntries_swigregister", NoQuoteEntries_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DefaultCstmApplVerID", _wrap_new_DefaultCstmApplVerID, METH_VARARGS, NULL},
	 { (char *)"delete_DefaultCstmApplVerID", _wrap_delete_DefaultCstmApplVerID, METH_VARARGS, NULL},
	 { (char *)"DefaultCstmApplVerID_swigregister", DefaultCstmApplVerID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeListMethod", _wrap_new_DerivativeListMethod, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeListMethod", _wrap_delete_DerivativeListMethod, METH_VARARGS, NULL},
	 { (char *)"DerivativeListMethod_swigregister", DerivativeListMethod_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSecurityXMLLen", _wrap_new_DerivativeSecurityXMLLen, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSecurityXMLLen", _wrap_delete_DerivativeSecurityXMLLen, METH_VARARGS, NULL},
	 { (char *)"DerivativeSecurityXMLLen_swigregister", DerivativeSecurityXMLLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegDatedDate", _wrap_new_LegDatedDate, METH_VARARGS, NULL},
	 { (char *)"delete_LegDatedDate", _wrap_delete_LegDatedDate, METH_VARARGS, NULL},
	 { (char *)"LegDatedDate_swigregister", LegDatedDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested2PartyIDSource", _wrap_new_Nested2PartyIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_Nested2PartyIDSource", _wrap_delete_Nested2PartyIDSource, METH_VARARGS, NULL},
	 { (char *)"Nested2PartyIDSource_swigregister", Nested2PartyIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingInstrRegistry", _wrap_new_UnderlyingInstrRegistry, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingInstrRegistry", _wrap_delete_UnderlyingInstrRegistry, METH_VARARGS, NULL},
	 { (char *)"UnderlyingInstrRegistry_swigregister", UnderlyingInstrRegistry_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IssueDate", _wrap_new_IssueDate, METH_VARARGS, NULL},
	 { (char *)"delete_IssueDate", _wrap_delete_IssueDate, METH_VARARGS, NULL},
	 { (char *)"IssueDate_swigregister", IssueDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityTradingStatus", _wrap_new_SecurityTradingStatus, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityTradingStatus", _wrap_delete_SecurityTradingStatus, METH_VARARGS, NULL},
	 { (char *)"SecurityTradingStatus_swigregister", SecurityTradingStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegOptAttribute", _wrap_new_LegOptAttribute, METH_VARARGS, NULL},
	 { (char *)"delete_LegOptAttribute", _wrap_delete_LegOptAttribute, METH_VARARGS, NULL},
	 { (char *)"LegOptAttribute_swigregister", LegOptAttribute_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaxFloor", _wrap_new_MaxFloor, METH_VARARGS, NULL},
	 { (char *)"delete_MaxFloor", _wrap_delete_MaxFloor, METH_VARARGS, NULL},
	 { (char *)"MaxFloor_swigregister", MaxFloor_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeLocaleOfIssue", _wrap_new_DerivativeLocaleOfIssue, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeLocaleOfIssue", _wrap_delete_DerivativeLocaleOfIssue, METH_VARARGS, NULL},
	 { (char *)"DerivativeLocaleOfIssue_swigregister", DerivativeLocaleOfIssue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OptPayAmount", _wrap_new_OptPayAmount, METH_VARARGS, NULL},
	 { (char *)"delete_OptPayAmount", _wrap_delete_OptPayAmount, METH_VARARGS, NULL},
	 { (char *)"OptPayAmount_swigregister", OptPayAmount_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingStipType", _wrap_new_UnderlyingStipType, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingStipType", _wrap_delete_UnderlyingStipType, METH_VARARGS, NULL},
	 { (char *)"UnderlyingStipType_swigregister", UnderlyingStipType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Rule80A", _wrap_new_Rule80A, METH_VARARGS, NULL},
	 { (char *)"delete_Rule80A", _wrap_delete_Rule80A, METH_VARARGS, NULL},
	 { (char *)"Rule80A_swigregister", Rule80A_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TotNoStrikes", _wrap_new_TotNoStrikes, METH_VARARGS, NULL},
	 { (char *)"delete_TotNoStrikes", _wrap_delete_TotNoStrikes, METH_VARARGS, NULL},
	 { (char *)"TotNoStrikes_swigregister", TotNoStrikes_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CorporateAction", _wrap_new_CorporateAction, METH_VARARGS, NULL},
	 { (char *)"delete_CorporateAction", _wrap_delete_CorporateAction, METH_VARARGS, NULL},
	 { (char *)"CorporateAction_swigregister", CorporateAction_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TerminationType", _wrap_new_TerminationType, METH_VARARGS, NULL},
	 { (char *)"delete_TerminationType", _wrap_delete_TerminationType, METH_VARARGS, NULL},
	 { (char *)"TerminationType_swigregister", TerminationType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegCouponRate", _wrap_new_LegCouponRate, METH_VARARGS, NULL},
	 { (char *)"delete_LegCouponRate", _wrap_delete_LegCouponRate, METH_VARARGS, NULL},
	 { (char *)"LegCouponRate_swigregister", LegCouponRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PosMaintAction", _wrap_new_PosMaintAction, METH_VARARGS, NULL},
	 { (char *)"delete_PosMaintAction", _wrap_delete_PosMaintAction, METH_VARARGS, NULL},
	 { (char *)"PosMaintAction_swigregister", PosMaintAction_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoSecurityTypes", _wrap_new_NoSecurityTypes, METH_VARARGS, NULL},
	 { (char *)"delete_NoSecurityTypes", _wrap_delete_NoSecurityTypes, METH_VARARGS, NULL},
	 { (char *)"NoSecurityTypes_swigregister", NoSecurityTypes_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ComplexEventPriceTimeType", _wrap_new_ComplexEventPriceTimeType, METH_VARARGS, NULL},
	 { (char *)"delete_ComplexEventPriceTimeType", _wrap_delete_ComplexEventPriceTimeType, METH_VARARGS, NULL},
	 { (char *)"ComplexEventPriceTimeType_swigregister", ComplexEventPriceTimeType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LastSwapPoints", _wrap_new_LastSwapPoints, METH_VARARGS, NULL},
	 { (char *)"delete_LastSwapPoints", _wrap_delete_LastSwapPoints, METH_VARARGS, NULL},
	 { (char *)"LastSwapPoints_swigregister", LastSwapPoints_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingFXRateCalc", _wrap_new_UnderlyingFXRateCalc, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingFXRateCalc", _wrap_delete_UnderlyingFXRateCalc, METH_VARARGS, NULL},
	 { (char *)"UnderlyingFXRateCalc_swigregister", UnderlyingFXRateCalc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ListStatusText", _wrap_new_ListStatusText, METH_VARARGS, NULL},
	 { (char *)"delete_ListStatusText", _wrap_delete_ListStatusText, METH_VARARGS, NULL},
	 { (char *)"ListStatusText_swigregister", ListStatusText_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OddLot", _wrap_new_OddLot, METH_VARARGS, NULL},
	 { (char *)"delete_OddLot", _wrap_delete_OddLot, METH_VARARGS, NULL},
	 { (char *)"OddLot_swigregister", OddLot_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BookingUnit", _wrap_new_BookingUnit, METH_VARARGS, NULL},
	 { (char *)"delete_BookingUnit", _wrap_delete_BookingUnit, METH_VARARGS, NULL},
	 { (char *)"BookingUnit_swigregister", BookingUnit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegAllocAcctIDSource", _wrap_new_LegAllocAcctIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_LegAllocAcctIDSource", _wrap_delete_LegAllocAcctIDSource, METH_VARARGS, NULL},
	 { (char *)"LegAllocAcctIDSource_swigregister", LegAllocAcctIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OnBehalfOfSendingTime", _wrap_new_OnBehalfOfSendingTime, METH_VARARGS, NULL},
	 { (char *)"delete_OnBehalfOfSendingTime", _wrap_delete_OnBehalfOfSendingTime, METH_VARARGS, NULL},
	 { (char *)"OnBehalfOfSendingTime_swigregister", OnBehalfOfSendingTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AllocStatus", _wrap_new_AllocStatus, METH_VARARGS, NULL},
	 { (char *)"delete_AllocStatus", _wrap_delete_AllocStatus, METH_VARARGS, NULL},
	 { (char *)"AllocStatus_swigregister", AllocStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ReferencePage", _wrap_new_ReferencePage, METH_VARARGS, NULL},
	 { (char *)"delete_ReferencePage", _wrap_delete_ReferencePage, METH_VARARGS, NULL},
	 { (char *)"ReferencePage_swigregister", ReferencePage_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeExerciseStyle", _wrap_new_DerivativeExerciseStyle, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeExerciseStyle", _wrap_delete_DerivativeExerciseStyle, METH_VARARGS, NULL},
	 { (char *)"DerivativeExerciseStyle_swigregister", DerivativeExerciseStyle_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplBegSeqNum", _wrap_new_ApplBegSeqNum, METH_VARARGS, NULL},
	 { (char *)"delete_ApplBegSeqNum", _wrap_delete_ApplBegSeqNum, METH_VARARGS, NULL},
	 { (char *)"ApplBegSeqNum_swigregister", ApplBegSeqNum_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CollRptID", _wrap_new_CollRptID, METH_VARARGS, NULL},
	 { (char *)"delete_CollRptID", _wrap_delete_CollRptID, METH_VARARGS, NULL},
	 { (char *)"CollRptID_swigregister", CollRptID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IncTaxInd", _wrap_new_IncTaxInd, METH_VARARGS, NULL},
	 { (char *)"delete_IncTaxInd", _wrap_delete_IncTaxInd, METH_VARARGS, NULL},
	 { (char *)"IncTaxInd_swigregister", IncTaxInd_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoBidDescriptors", _wrap_new_NoBidDescriptors, METH_VARARGS, NULL},
	 { (char *)"delete_NoBidDescriptors", _wrap_delete_NoBidDescriptors, METH_VARARGS, NULL},
	 { (char *)"NoBidDescriptors_swigregister", NoBidDescriptors_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegCouponPaymentDate", _wrap_new_LegCouponPaymentDate, METH_VARARGS, NULL},
	 { (char *)"delete_LegCouponPaymentDate", _wrap_delete_LegCouponPaymentDate, METH_VARARGS, NULL},
	 { (char *)"LegCouponPaymentDate_swigregister", LegCouponPaymentDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoUnderlyingLegSecurityAltID", _wrap_new_NoUnderlyingLegSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"delete_NoUnderlyingLegSecurityAltID", _wrap_delete_NoUnderlyingLegSecurityAltID, METH_VARARGS, NULL},
	 { (char *)"NoUnderlyingLegSecurityAltID_swigregister", NoUnderlyingLegSecurityAltID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ReversalIndicator", _wrap_new_ReversalIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_ReversalIndicator", _wrap_delete_ReversalIndicator, METH_VARARGS, NULL},
	 { (char *)"ReversalIndicator_swigregister", ReversalIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CheckSum", _wrap_new_CheckSum, METH_VARARGS, NULL},
	 { (char *)"delete_CheckSum", _wrap_delete_CheckSum, METH_VARARGS, NULL},
	 { (char *)"CheckSum_swigregister", CheckSum_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TargetSubID", _wrap_new_TargetSubID, METH_VARARGS, NULL},
	 { (char *)"delete_TargetSubID", _wrap_delete_TargetSubID, METH_VARARGS, NULL},
	 { (char *)"TargetSubID_swigregister", TargetSubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PosReqStatus", _wrap_new_PosReqStatus, METH_VARARGS, NULL},
	 { (char *)"delete_PosReqStatus", _wrap_delete_PosReqStatus, METH_VARARGS, NULL},
	 { (char *)"PosReqStatus_swigregister", PosReqStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PriorityIndicator", _wrap_new_PriorityIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_PriorityIndicator", _wrap_delete_PriorityIndicator, METH_VARARGS, NULL},
	 { (char *)"PriorityIndicator_swigregister", PriorityIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegCFICode", _wrap_new_UnderlyingLegCFICode, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegCFICode", _wrap_delete_UnderlyingLegCFICode, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegCFICode_swigregister", UnderlyingLegCFICode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeTimeUnit", _wrap_new_DerivativeTimeUnit, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeTimeUnit", _wrap_delete_DerivativeTimeUnit, METH_VARARGS, NULL},
	 { (char *)"DerivativeTimeUnit_swigregister", DerivativeTimeUnit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoNested3PartyIDs", _wrap_new_NoNested3PartyIDs, METH_VARARGS, NULL},
	 { (char *)"delete_NoNested3PartyIDs", _wrap_delete_NoNested3PartyIDs, METH_VARARGS, NULL},
	 { (char *)"NoNested3PartyIDs_swigregister", NoNested3PartyIDs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LiquidityPctHigh", _wrap_new_LiquidityPctHigh, METH_VARARGS, NULL},
	 { (char *)"delete_LiquidityPctHigh", _wrap_delete_LiquidityPctHigh, METH_VARARGS, NULL},
	 { (char *)"LiquidityPctHigh_swigregister", LiquidityPctHigh_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MoneyLaunderingStatus", _wrap_new_MoneyLaunderingStatus, METH_VARARGS, NULL},
	 { (char *)"delete_MoneyLaunderingStatus", _wrap_delete_MoneyLaunderingStatus, METH_VARARGS, NULL},
	 { (char *)"MoneyLaunderingStatus_swigregister", MoneyLaunderingStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested4PartySubID", _wrap_new_Nested4PartySubID, METH_VARARGS, NULL},
	 { (char *)"delete_Nested4PartySubID", _wrap_delete_Nested4PartySubID, METH_VARARGS, NULL},
	 { (char *)"Nested4PartySubID_swigregister", Nested4PartySubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSecurityExchange", _wrap_new_DerivativeSecurityExchange, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSecurityExchange", _wrap_delete_DerivativeSecurityExchange, METH_VARARGS, NULL},
	 { (char *)"DerivativeSecurityExchange_swigregister", DerivativeSecurityExchange_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LotType", _wrap_new_LotType, METH_VARARGS, NULL},
	 { (char *)"delete_LotType", _wrap_delete_LotType, METH_VARARGS, NULL},
	 { (char *)"LotType_swigregister", LotType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ContIntRptID", _wrap_new_ContIntRptID, METH_VARARGS, NULL},
	 { (char *)"delete_ContIntRptID", _wrap_delete_ContIntRptID, METH_VARARGS, NULL},
	 { (char *)"ContIntRptID_swigregister", ContIntRptID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteCondition", _wrap_new_QuoteCondition, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteCondition", _wrap_delete_QuoteCondition, METH_VARARGS, NULL},
	 { (char *)"QuoteCondition_swigregister", QuoteCondition_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ComplexEventStartTime", _wrap_new_ComplexEventStartTime, METH_VARARGS, NULL},
	 { (char *)"delete_ComplexEventStartTime", _wrap_delete_ComplexEventStartTime, METH_VARARGS, NULL},
	 { (char *)"ComplexEventStartTime_swigregister", ComplexEventStartTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoComplexEvents", _wrap_new_NoComplexEvents, METH_VARARGS, NULL},
	 { (char *)"delete_NoComplexEvents", _wrap_delete_NoComplexEvents, METH_VARARGS, NULL},
	 { (char *)"NoComplexEvents_swigregister", NoComplexEvents_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeContractMultiplier", _wrap_new_DerivativeContractMultiplier, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeContractMultiplier", _wrap_delete_DerivativeContractMultiplier, METH_VARARGS, NULL},
	 { (char *)"DerivativeContractMultiplier_swigregister", DerivativeContractMultiplier_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeSecurityStatus", _wrap_new_DerivativeSecurityStatus, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeSecurityStatus", _wrap_delete_DerivativeSecurityStatus, METH_VARARGS, NULL},
	 { (char *)"DerivativeSecurityStatus_swigregister", DerivativeSecurityStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeProductComplex", _wrap_new_DerivativeProductComplex, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeProductComplex", _wrap_delete_DerivativeProductComplex, METH_VARARGS, NULL},
	 { (char *)"DerivativeProductComplex_swigregister", DerivativeProductComplex_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TriggerSymbol", _wrap_new_TriggerSymbol, METH_VARARGS, NULL},
	 { (char *)"delete_TriggerSymbol", _wrap_delete_TriggerSymbol, METH_VARARGS, NULL},
	 { (char *)"TriggerSymbol_swigregister", TriggerSymbol_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLocaleOfIssue", _wrap_new_UnderlyingLocaleOfIssue, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLocaleOfIssue", _wrap_delete_UnderlyingLocaleOfIssue, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLocaleOfIssue_swigregister", UnderlyingLocaleOfIssue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SendingTime", _wrap_new_SendingTime, METH_VARARGS, NULL},
	 { (char *)"delete_SendingTime", _wrap_delete_SendingTime, METH_VARARGS, NULL},
	 { (char *)"SendingTime_swigregister", SendingTime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ComplexEventStartDate", _wrap_new_ComplexEventStartDate, METH_VARARGS, NULL},
	 { (char *)"delete_ComplexEventStartDate", _wrap_delete_ComplexEventStartDate, METH_VARARGS, NULL},
	 { (char *)"ComplexEventStartDate_swigregister", ComplexEventStartDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingRestructuringType", _wrap_new_UnderlyingRestructuringType, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingRestructuringType", _wrap_delete_UnderlyingRestructuringType, METH_VARARGS, NULL},
	 { (char *)"UnderlyingRestructuringType_swigregister", UnderlyingRestructuringType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegUnitOfMeasureQty", _wrap_new_LegUnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"delete_LegUnitOfMeasureQty", _wrap_delete_LegUnitOfMeasureQty, METH_VARARGS, NULL},
	 { (char *)"LegUnitOfMeasureQty_swigregister", LegUnitOfMeasureQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoTrdRegTimestamps", _wrap_new_NoTrdRegTimestamps, METH_VARARGS, NULL},
	 { (char *)"delete_NoTrdRegTimestamps", _wrap_delete_NoTrdRegTimestamps, METH_VARARGS, NULL},
	 { (char *)"NoTrdRegTimestamps_swigregister", NoTrdRegTimestamps_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SendingDate", _wrap_new_SendingDate, METH_VARARGS, NULL},
	 { (char *)"delete_SendingDate", _wrap_delete_SendingDate, METH_VARARGS, NULL},
	 { (char *)"SendingDate_swigregister", SendingDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TimeToExpiration", _wrap_new_TimeToExpiration, METH_VARARGS, NULL},
	 { (char *)"delete_TimeToExpiration", _wrap_delete_TimeToExpiration, METH_VARARGS, NULL},
	 { (char *)"TimeToExpiration_swigregister", TimeToExpiration_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegAllocQty", _wrap_new_LegAllocQty, METH_VARARGS, NULL},
	 { (char *)"delete_LegAllocQty", _wrap_delete_LegAllocQty, METH_VARARGS, NULL},
	 { (char *)"LegAllocQty_swigregister", LegAllocQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlLocation", _wrap_new_SettlLocation, METH_VARARGS, NULL},
	 { (char *)"delete_SettlLocation", _wrap_delete_SettlLocation, METH_VARARGS, NULL},
	 { (char *)"SettlLocation_swigregister", SettlLocation_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingExerciseStyle", _wrap_new_UnderlyingExerciseStyle, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingExerciseStyle", _wrap_delete_UnderlyingExerciseStyle, METH_VARARGS, NULL},
	 { (char *)"UnderlyingExerciseStyle_swigregister", UnderlyingExerciseStyle_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CashSettlAgentContactName", _wrap_new_CashSettlAgentContactName, METH_VARARGS, NULL},
	 { (char *)"delete_CashSettlAgentContactName", _wrap_delete_CashSettlAgentContactName, METH_VARARGS, NULL},
	 { (char *)"CashSettlAgentContactName_swigregister", CashSettlAgentContactName_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegRepurchaseRate", _wrap_new_LegRepurchaseRate, METH_VARARGS, NULL},
	 { (char *)"delete_LegRepurchaseRate", _wrap_delete_LegRepurchaseRate, METH_VARARGS, NULL},
	 { (char *)"LegRepurchaseRate_swigregister", LegRepurchaseRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplResponseID", _wrap_new_ApplResponseID, METH_VARARGS, NULL},
	 { (char *)"delete_ApplResponseID", _wrap_delete_ApplResponseID, METH_VARARGS, NULL},
	 { (char *)"ApplResponseID_swigregister", ApplResponseID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoDerivativeInstrAttrib", _wrap_new_NoDerivativeInstrAttrib, METH_VARARGS, NULL},
	 { (char *)"delete_NoDerivativeInstrAttrib", _wrap_delete_NoDerivativeInstrAttrib, METH_VARARGS, NULL},
	 { (char *)"NoDerivativeInstrAttrib_swigregister", NoDerivativeInstrAttrib_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeStrikeMultiplier", _wrap_new_DerivativeStrikeMultiplier, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeStrikeMultiplier", _wrap_delete_DerivativeStrikeMultiplier, METH_VARARGS, NULL},
	 { (char *)"DerivativeStrikeMultiplier_swigregister", DerivativeStrikeMultiplier_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegStrikeCurrency", _wrap_new_LegStrikeCurrency, METH_VARARGS, NULL},
	 { (char *)"delete_LegStrikeCurrency", _wrap_delete_LegStrikeCurrency, METH_VARARGS, NULL},
	 { (char *)"LegStrikeCurrency_swigregister", LegStrikeCurrency_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecurityStatusReqID", _wrap_new_SecurityStatusReqID, METH_VARARGS, NULL},
	 { (char *)"delete_SecurityStatusReqID", _wrap_delete_SecurityStatusReqID, METH_VARARGS, NULL},
	 { (char *)"SecurityStatusReqID_swigregister", SecurityStatusReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecureDataLen", _wrap_new_SecureDataLen, METH_VARARGS, NULL},
	 { (char *)"delete_SecureDataLen", _wrap_delete_SecureDataLen, METH_VARARGS, NULL},
	 { (char *)"SecureDataLen_swigregister", SecureDataLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DiscretionScope", _wrap_new_DiscretionScope, METH_VARARGS, NULL},
	 { (char *)"delete_DiscretionScope", _wrap_delete_DiscretionScope, METH_VARARGS, NULL},
	 { (char *)"DiscretionScope_swigregister", DiscretionScope_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OwnerType", _wrap_new_OwnerType, METH_VARARGS, NULL},
	 { (char *)"delete_OwnerType", _wrap_delete_OwnerType, METH_VARARGS, NULL},
	 { (char *)"OwnerType_swigregister", OwnerType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Shares", _wrap_new_Shares, METH_VARARGS, NULL},
	 { (char *)"delete_Shares", _wrap_delete_Shares, METH_VARARGS, NULL},
	 { (char *)"Shares_swigregister", Shares_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Yield", _wrap_new_Yield, METH_VARARGS, NULL},
	 { (char *)"delete_Yield", _wrap_delete_Yield, METH_VARARGS, NULL},
	 { (char *)"Yield_swigregister", Yield_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteRespID", _wrap_new_QuoteRespID, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteRespID", _wrap_delete_QuoteRespID, METH_VARARGS, NULL},
	 { (char *)"QuoteRespID_swigregister", QuoteRespID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested3PartySubID", _wrap_new_Nested3PartySubID, METH_VARARGS, NULL},
	 { (char *)"delete_Nested3PartySubID", _wrap_delete_Nested3PartySubID, METH_VARARGS, NULL},
	 { (char *)"Nested3PartySubID_swigregister", Nested3PartySubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplQueueResolution", _wrap_new_ApplQueueResolution, METH_VARARGS, NULL},
	 { (char *)"delete_ApplQueueResolution", _wrap_delete_ApplQueueResolution, METH_VARARGS, NULL},
	 { (char *)"ApplQueueResolution_swigregister", ApplQueueResolution_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TrdRegTimestampOrigin", _wrap_new_TrdRegTimestampOrigin, METH_VARARGS, NULL},
	 { (char *)"delete_TrdRegTimestampOrigin", _wrap_delete_TrdRegTimestampOrigin, METH_VARARGS, NULL},
	 { (char *)"TrdRegTimestampOrigin_swigregister", TrdRegTimestampOrigin_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested2PartyRole", _wrap_new_Nested2PartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_Nested2PartyRole", _wrap_delete_Nested2PartyRole, METH_VARARGS, NULL},
	 { (char *)"Nested2PartyRole_swigregister", Nested2PartyRole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nested2PartyID", _wrap_new_Nested2PartyID, METH_VARARGS, NULL},
	 { (char *)"delete_Nested2PartyID", _wrap_delete_Nested2PartyID, METH_VARARGS, NULL},
	 { (char *)"Nested2PartyID_swigregister", Nested2PartyID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BidSize", _wrap_new_BidSize, METH_VARARGS, NULL},
	 { (char *)"delete_BidSize", _wrap_delete_BidSize, METH_VARARGS, NULL},
	 { (char *)"BidSize_swigregister", BidSize_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegSymbolSfx", _wrap_new_LegSymbolSfx, METH_VARARGS, NULL},
	 { (char *)"delete_LegSymbolSfx", _wrap_delete_LegSymbolSfx, METH_VARARGS, NULL},
	 { (char *)"LegSymbolSfx_swigregister", LegSymbolSfx_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteResponseLevel", _wrap_new_QuoteResponseLevel, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteResponseLevel", _wrap_delete_QuoteResponseLevel, METH_VARARGS, NULL},
	 { (char *)"QuoteResponseLevel_swigregister", QuoteResponseLevel_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BodyLength", _wrap_new_BodyLength, METH_VARARGS, NULL},
	 { (char *)"delete_BodyLength", _wrap_delete_BodyLength, METH_VARARGS, NULL},
	 { (char *)"BodyLength_swigregister", BodyLength_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ListExecInst", _wrap_new_ListExecInst, METH_VARARGS, NULL},
	 { (char *)"delete_ListExecInst", _wrap_delete_ListExecInst, METH_VARARGS, NULL},
	 { (char *)"ListExecInst_swigregister", ListExecInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExecAckStatus", _wrap_new_ExecAckStatus, METH_VARARGS, NULL},
	 { (char *)"delete_ExecAckStatus", _wrap_delete_ExecAckStatus, METH_VARARGS, NULL},
	 { (char *)"ExecAckStatus_swigregister", ExecAckStatus_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlDate2", _wrap_new_SettlDate2, METH_VARARGS, NULL},
	 { (char *)"delete_SettlDate2", _wrap_delete_SettlDate2, METH_VARARGS, NULL},
	 { (char *)"SettlDate2_swigregister", SettlDate2_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NetGrossInd", _wrap_new_NetGrossInd, METH_VARARGS, NULL},
	 { (char *)"delete_NetGrossInd", _wrap_delete_NetGrossInd, METH_VARARGS, NULL},
	 { (char *)"NetGrossInd_swigregister", NetGrossInd_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingSecurityAltIDSource", _wrap_new_UnderlyingSecurityAltIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingSecurityAltIDSource", _wrap_delete_UnderlyingSecurityAltIDSource, METH_VARARGS, NULL},
	 { (char *)"UnderlyingSecurityAltIDSource_swigregister", UnderlyingSecurityAltIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TestReqID", _wrap_new_TestReqID, METH_VARARGS, NULL},
	 { (char *)"delete_TestReqID", _wrap_delete_TestReqID, METH_VARARGS, NULL},
	 { (char *)"TestReqID_swigregister", TestReqID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CxlType", _wrap_new_CxlType, METH_VARARGS, NULL},
	 { (char *)"delete_CxlType", _wrap_delete_CxlType, METH_VARARGS, NULL},
	 { (char *)"CxlType_swigregister", CxlType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingCreditRating", _wrap_new_UnderlyingCreditRating, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingCreditRating", _wrap_delete_UnderlyingCreditRating, METH_VARARGS, NULL},
	 { (char *)"UnderlyingCreditRating_swigregister", UnderlyingCreditRating_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AvgPxPrecision", _wrap_new_AvgPxPrecision, METH_VARARGS, NULL},
	 { (char *)"delete_AvgPxPrecision", _wrap_delete_AvgPxPrecision, METH_VARARGS, NULL},
	 { (char *)"AvgPxPrecision_swigregister", AvgPxPrecision_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BenchmarkPriceType", _wrap_new_BenchmarkPriceType, METH_VARARGS, NULL},
	 { (char *)"delete_BenchmarkPriceType", _wrap_delete_BenchmarkPriceType, METH_VARARGS, NULL},
	 { (char *)"BenchmarkPriceType_swigregister", BenchmarkPriceType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DeskTypeSource", _wrap_new_DeskTypeSource, METH_VARARGS, NULL},
	 { (char *)"delete_DeskTypeSource", _wrap_delete_DeskTypeSource, METH_VARARGS, NULL},
	 { (char *)"DeskTypeSource_swigregister", DeskTypeSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DiscretionRoundDirection", _wrap_new_DiscretionRoundDirection, METH_VARARGS, NULL},
	 { (char *)"delete_DiscretionRoundDirection", _wrap_delete_DiscretionRoundDirection, METH_VARARGS, NULL},
	 { (char *)"DiscretionRoundDirection_swigregister", DiscretionRoundDirection_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrigSecondaryTradeID", _wrap_new_OrigSecondaryTradeID, METH_VARARGS, NULL},
	 { (char *)"delete_OrigSecondaryTradeID", _wrap_delete_OrigSecondaryTradeID, METH_VARARGS, NULL},
	 { (char *)"OrigSecondaryTradeID_swigregister", OrigSecondaryTradeID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ReceivedDeptID", _wrap_new_ReceivedDeptID, METH_VARARGS, NULL},
	 { (char *)"delete_ReceivedDeptID", _wrap_delete_ReceivedDeptID, METH_VARARGS, NULL},
	 { (char *)"ReceivedDeptID_swigregister", ReceivedDeptID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MaturityNetMoney", _wrap_new_MaturityNetMoney, METH_VARARGS, NULL},
	 { (char *)"delete_MaturityNetMoney", _wrap_delete_MaturityNetMoney, METH_VARARGS, NULL},
	 { (char *)"MaturityNetMoney_swigregister", MaturityNetMoney_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BidDescriptorType", _wrap_new_BidDescriptorType, METH_VARARGS, NULL},
	 { (char *)"delete_BidDescriptorType", _wrap_delete_BidDescriptorType, METH_VARARGS, NULL},
	 { (char *)"BidDescriptorType_swigregister", BidDescriptorType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativeInstrumentPartySubID", _wrap_new_DerivativeInstrumentPartySubID, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativeInstrumentPartySubID", _wrap_delete_DerivativeInstrumentPartySubID, METH_VARARGS, NULL},
	 { (char *)"DerivativeInstrumentPartySubID_swigregister", DerivativeInstrumentPartySubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NetworkStatusResponseType", _wrap_new_NetworkStatusResponseType, METH_VARARGS, NULL},
	 { (char *)"delete_NetworkStatusResponseType", _wrap_delete_NetworkStatusResponseType, METH_VARARGS, NULL},
	 { (char *)"NetworkStatusResponseType_swigregister", NetworkStatusResponseType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DateOfBirth", _wrap_new_DateOfBirth, METH_VARARGS, NULL},
	 { (char *)"delete_DateOfBirth", _wrap_delete_DateOfBirth, METH_VARARGS, NULL},
	 { (char *)"DateOfBirth_swigregister", DateOfBirth_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StartStrikePxRange", _wrap_new_StartStrikePxRange, METH_VARARGS, NULL},
	 { (char *)"delete_StartStrikePxRange", _wrap_delete_StartStrikePxRange, METH_VARARGS, NULL},
	 { (char *)"StartStrikePxRange_swigregister", StartStrikePxRange_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UndlyInstrumentPartySubID", _wrap_new_UndlyInstrumentPartySubID, METH_VARARGS, NULL},
	 { (char *)"delete_UndlyInstrumentPartySubID", _wrap_delete_UndlyInstrumentPartySubID, METH_VARARGS, NULL},
	 { (char *)"UndlyInstrumentPartySubID_swigregister", UndlyInstrumentPartySubID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SecondaryTradeReportRefID", _wrap_new_SecondaryTradeReportRefID, METH_VARARGS, NULL},
	 { (char *)"delete_SecondaryTradeReportRefID", _wrap_delete_SecondaryTradeReportRefID, METH_VARARGS, NULL},
	 { (char *)"SecondaryTradeReportRefID_swigregister", SecondaryTradeReportRefID_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingCPRegType", _wrap_new_UnderlyingCPRegType, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingCPRegType", _wrap_delete_UnderlyingCPRegType, METH_VARARGS, NULL},
	 { (char *)"UnderlyingCPRegType_swigregister", UnderlyingCPRegType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SignatureLength", _wrap_new_SignatureLength, METH_VARARGS, NULL},
	 { (char *)"delete_SignatureLength", _wrap_delete_SignatureLength, METH_VARARGS, NULL},
	 { (char *)"SignatureLength_swigregister", SignatureLength_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OrderQty", _wrap_new_OrderQty, METH_VARARGS, NULL},
	 { (char *)"delete_OrderQty", _wrap_delete_OrderQty, METH_VARARGS, NULL},
	 { (char *)"OrderQty_swigregister", OrderQty_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OriginalNotionalPercentageOutstanding", _wrap_new_OriginalNotionalPercentageOutstanding, METH_VARARGS, NULL},
	 { (char *)"delete_OriginalNotionalPercentageOutstanding", _wrap_delete_OriginalNotionalPercentageOutstanding, METH_VARARGS, NULL},
	 { (char *)"OriginalNotionalPercentageOutstanding_swigregister", OriginalNotionalPercentageOutstanding_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingTimeUnit", _wrap_new_UnderlyingTimeUnit, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingTimeUnit", _wrap_delete_UnderlyingTimeUnit, METH_VARARGS, NULL},
	 { (char *)"UnderlyingTimeUnit_swigregister", UnderlyingTimeUnit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedHeadlineLen", _wrap_new_EncodedHeadlineLen, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedHeadlineLen", _wrap_delete_EncodedHeadlineLen, METH_VARARGS, NULL},
	 { (char *)"EncodedHeadlineLen_swigregister", EncodedHeadlineLen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoRegistDtls", _wrap_new_NoRegistDtls, METH_VARARGS, NULL},
	 { (char *)"delete_NoRegistDtls", _wrap_delete_NoRegistDtls, METH_VARARGS, NULL},
	 { (char *)"NoRegistDtls_swigregister", NoRegistDtls_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StrategyParameterValue", _wrap_new_StrategyParameterValue, METH_VARARGS, NULL},
	 { (char *)"delete_StrategyParameterValue", _wrap_delete_StrategyParameterValue, METH_VARARGS, NULL},
	 { (char *)"StrategyParameterValue_swigregister", StrategyParameterValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoInstrumentParties", _wrap_new_NoInstrumentParties, METH_VARARGS, NULL},
	 { (char *)"delete_NoInstrumentParties", _wrap_delete_NoInstrumentParties, METH_VARARGS, NULL},
	 { (char *)"NoInstrumentParties_swigregister", NoInstrumentParties_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_QuoteType", _wrap_new_QuoteType, METH_VARARGS, NULL},
	 { (char *)"delete_QuoteType", _wrap_delete_QuoteType, METH_VARARGS, NULL},
	 { (char *)"QuoteType_swigregister", QuoteType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NoStrategyParameters", _wrap_new_NoStrategyParameters, METH_VARARGS, NULL},
	 { (char *)"delete_NoStrategyParameters", _wrap_delete_NoStrategyParameters, METH_VARARGS, NULL},
	 { (char *)"NoStrategyParameters_swigregister", NoStrategyParameters_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IndividualAllocRejCode", _wrap_new_IndividualAllocRejCode, METH_VARARGS, NULL},
	 { (char *)"delete_IndividualAllocRejCode", _wrap_delete_IndividualAllocRejCode, METH_VARARGS, NULL},
	 { (char *)"IndividualAllocRejCode_swigregister", IndividualAllocRejCode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DiscretionInst", _wrap_new_DiscretionInst, METH_VARARGS, NULL},
	 { (char *)"delete_DiscretionInst", _wrap_delete_DiscretionInst, METH_VARARGS, NULL},
	 { (char *)"DiscretionInst_swigregister", DiscretionInst_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TargetPartyRole", _wrap_new_TargetPartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_TargetPartyRole", _wrap_delete_TargetPartyRole, METH_VARARGS, NULL},
	 { (char *)"TargetPartyRole_swigregister", TargetPartyRole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CrossPrioritization", _wrap_new_CrossPrioritization, METH_VARARGS, NULL},
	 { (char *)"delete_CrossPrioritization", _wrap_delete_CrossPrioritization, METH_VARARGS, NULL},
	 { (char *)"CrossPrioritization_swigregister", CrossPrioritization_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EncodedListStatusText", _wrap_new_EncodedListStatusText, METH_VARARGS, NULL},
	 { (char *)"delete_EncodedListStatusText", _wrap_delete_EncodedListStatusText, METH_VARARGS, NULL},
	 { (char *)"EncodedListStatusText_swigregister", EncodedListStatusText_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_IOIOthSvc", _wrap_new_IOIOthSvc, METH_VARARGS, NULL},
	 { (char *)"delete_IOIOthSvc", _wrap_delete_IOIOthSvc, METH_VARARGS, NULL},
	 { (char *)"IOIOthSvc_swigregister", IOIOthSvc_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LegIssueDate", _wrap_new_LegIssueDate, METH_VARARGS, NULL},
	 { (char *)"delete_LegIssueDate", _wrap_delete_LegIssueDate, METH_VARARGS, NULL},
	 { (char *)"LegIssueDate_swigregister", LegIssueDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MDReqRejReason", _wrap_new_MDReqRejReason, METH_VARARGS, NULL},
	 { (char *)"delete_MDReqRejReason", _wrap_delete_MDReqRejReason, METH_VARARGS, NULL},
	 { (char *)"MDReqRejReason_swigregister", MDReqRejReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ApplReqType", _wrap_new_ApplReqType, METH_VARARGS, NULL},
	 { (char *)"delete_ApplReqType", _wrap_delete_ApplReqType, METH_VARARGS, NULL},
	 { (char *)"ApplReqType_swigregister", ApplReqType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Country", _wrap_new_Country, METH_VARARGS, NULL},
	 { (char *)"delete_Country", _wrap_delete_Country, METH_VARARGS, NULL},
	 { (char *)"Country_swigregister", Country_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingLegSecurityIDSource", _wrap_new_UnderlyingLegSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingLegSecurityIDSource", _wrap_delete_UnderlyingLegSecurityIDSource, METH_VARARGS, NULL},
	 { (char *)"UnderlyingLegSecurityIDSource_swigregister", UnderlyingLegSecurityIDSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FlexProductEligibilityIndicator", _wrap_new_FlexProductEligibilityIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_FlexProductEligibilityIndicator", _wrap_delete_FlexProductEligibilityIndicator, METH_VARARGS, NULL},
	 { (char *)"FlexProductEligibilityIndicator_swigregister", FlexProductEligibilityIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AggressorIndicator", _wrap_new_AggressorIndicator, METH_VARARGS, NULL},
	 { (char *)"delete_AggressorIndicator", _wrap_delete_AggressorIndicator, METH_VARARGS, NULL},
	 { (char *)"AggressorIndicator_swigregister", AggressorIndicator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ExecPriceAdjustment", _wrap_new_ExecPriceAdjustment, METH_VARARGS, NULL},
	 { (char *)"delete_ExecPriceAdjustment", _wrap_delete_ExecPriceAdjustment, METH_VARARGS, NULL},
	 { (char *)"ExecPriceAdjustment_swigregister", ExecPriceAdjustment_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BusinessRejectReason", _wrap_new_BusinessRejectReason, METH_VARARGS, NULL},
	 { (char *)"delete_BusinessRejectReason", _wrap_delete_BusinessRejectReason, METH_VARARGS, NULL},
	 { (char *)"BusinessRejectReason_swigregister", BusinessRejectReason_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TradeDate", _wrap_new_TradeDate, METH_VARARGS, NULL},
	 { (char *)"delete_TradeDate", _wrap_delete_TradeDate, METH_VARARGS, NULL},
	 { (char *)"TradeDate_swigregister", TradeDate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingPutOrCall", _wrap_new_UnderlyingPutOrCall, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingPutOrCall", _wrap_delete_UnderlyingPutOrCall, METH_VARARGS, NULL},
	 { (char *)"UnderlyingPutOrCall_swigregister", UnderlyingPutOrCall_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_UnderlyingInstrumentPartyRole", _wrap_new_UnderlyingInstrumentPartyRole, METH_VARARGS, NULL},
	 { (char *)"delete_UnderlyingInstrumentPartyRole", _wrap_delete_UnderlyingInstrumentPartyRole, METH_VARARGS, NULL},
	 { (char *)"UnderlyingInstrumentPartyRole_swigregister", UnderlyingInstrumentPartyRole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DerivativePositionLimit", _wrap_new_DerivativePositionLimit, METH_VARARGS, NULL},
	 { (char *)"delete_DerivativePositionLimit", _wrap_delete_DerivativePositionLimit, METH_VARARGS, NULL},
	 { (char *)"DerivativePositionLimit_swigregister", DerivativePositionLimit_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TierCode", _wrap_new_TierCode, METH_VARARGS, NULL},
	 { (char *)"delete_TierCode", _wrap_delete_TierCode, METH_VARARGS, NULL},
	 { (char *)"TierCode_swigregister", TierCode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BookingType", _wrap_new_BookingType, METH_VARARGS, NULL},
	 { (char *)"delete_BookingType", _wrap_delete_BookingType, METH_VARARGS, NULL},
	 { (char *)"BookingType_swigregister", BookingType_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StipulationValue", _wrap_new_StipulationValue, METH_VARARGS, NULL},
	 { (char *)"delete_StipulationValue", _wrap_delete_StipulationValue, METH_VARARGS, NULL},
	 { (char *)"StipulationValue_swigregister", StipulationValue_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SettlCurrBidFxRate", _wrap_new_SettlCurrBidFxRate, METH_VARARGS, NULL},
	 { (char *)"delete_SettlCurrBidFxRate", _wrap_delete_SettlCurrBidFxRate, METH_VARARGS, NULL},
	 { (char *)"SettlCurrBidFxRate_swigregister", SettlCurrBidFxRate_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SessionID", _wrap_new_SessionID, METH_VARARGS, NULL},
	 { (char *)"SessionID_getBeginString", _wrap_SessionID_getBeginString, METH_VARARGS, NULL},
	 { (char *)"SessionID_getSenderCompID", _wrap_SessionID_getSenderCompID, METH_VARARGS, NULL},
	 { (char *)"SessionID_getTargetCompID", _wrap_SessionID_getTargetCompID, METH_VARARGS, NULL},
	 { (char *)"SessionID_getSessionQualifier", _wrap_SessionID_getSessionQualifier, METH_VARARGS, NULL},
	 { (char *)"SessionID_isFIXT", _wrap_SessionID_isFIXT, METH_VARARGS, NULL},
	 { (char *)"SessionID_toStringFrozen", _wrap_SessionID_toStringFrozen, METH_VARARGS, NULL},
	 { (char *)"SessionID_fromString", _wrap_SessionID_fromString, METH_VARARGS, NULL},
	 { (char *)"SessionID_toString", _wrap_SessionID_toString, METH_VARARGS, NULL},
	 { (char *)"SessionID___invert__", _wrap_SessionID___invert__, METH_VARARGS, NULL},
	 { (char *)"SessionID___str__", _wrap_SessionID___str__, METH_VARARGS, NULL},
	 { (char *)"delete_SessionID", _wrap_delete_SessionID, METH_VARARGS, NULL},
	 { (char *)"SessionID_swigregister", SessionID_swigregister, METH_VARARGS, NULL},
	 { (char *)"__lt__", _wrap___lt__, METH_VARARGS, NULL},
	 { (char *)"__eq__", _wrap___eq__, METH_VARARGS, NULL},
	 { (char *)"__ne__", _wrap___ne__, METH_VARARGS, NULL},
	 { (char *)"new_Dictionary", _wrap_new_Dictionary, METH_VARARGS, NULL},
	 { (char *)"delete_Dictionary", _wrap_delete_Dictionary, METH_VARARGS, NULL},
	 { (char *)"Dictionary_getName", _wrap_Dictionary_getName, METH_VARARGS, NULL},
	 { (char *)"Dictionary_size", _wrap_Dictionary_size, METH_VARARGS, NULL},
	 { (char *)"Dictionary_getString", _wrap_Dictionary_getString, METH_VARARGS, NULL},
	 { (char *)"Dictionary_getLong", _wrap_Dictionary_getLong, METH_VARARGS, NULL},
	 { (char *)"Dictionary_getDouble", _wrap_Dictionary_getDouble, METH_VARARGS, NULL},
	 { (char *)"Dictionary_getBool", _wrap_Dictionary_getBool, METH_VARARGS, NULL},
	 { (char *)"Dictionary_getDay", _wrap_Dictionary_getDay, METH_VARARGS, NULL},
	 { (char *)"Dictionary_setString", _wrap_Dictionary_setString, METH_VARARGS, NULL},
	 { (char *)"Dictionary_setLong", _wrap_Dictionary_setLong, METH_VARARGS, NULL},
	 { (char *)"Dictionary_setDouble", _wrap_Dictionary_setDouble, METH_VARARGS, NULL},
	 { (char *)"Dictionary_setBool", _wrap_Dictionary_setBool, METH_VARARGS, NULL},
	 { (char *)"Dictionary_setDay", _wrap_Dictionary_setDay, METH_VARARGS, NULL},
	 { (char *)"Dictionary_has", _wrap_Dictionary_has, METH_VARARGS, NULL},
	 { (char *)"Dictionary_merge", _wrap_Dictionary_merge, METH_VARARGS, NULL},
	 { (char *)"Dictionary_begin", _wrap_Dictionary_begin, METH_VARARGS, NULL},
	 { (char *)"Dictionary_end", _wrap_Dictionary_end, METH_VARARGS, NULL},
	 { (char *)"Dictionary_swigregister", Dictionary_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SessionSettings", _wrap_new_SessionSettings, METH_VARARGS, NULL},
	 { (char *)"SessionSettings_has", _wrap_SessionSettings_has, METH_VARARGS, NULL},
	 { (char *)"SessionSettings_get", _wrap_SessionSettings_get, METH_VARARGS, NULL},
	 { (char *)"SessionSettings_set", _wrap_SessionSettings_set, METH_VARARGS, NULL},
	 { (char *)"SessionSettings_size", _wrap_SessionSettings_size, METH_VARARGS, NULL},
	 { (char *)"SessionSettings_getSessions", _wrap_SessionSettings_getSessions, METH_VARARGS, NULL},
	 { (char *)"delete_SessionSettings", _wrap_delete_SessionSettings, METH_VARARGS, NULL},
	 { (char *)"SessionSettings_swigregister", SessionSettings_swigregister, METH_VARARGS, NULL},
	 { (char *)"__rshift__", _wrap___rshift__, METH_VARARGS, NULL},
	 { (char *)"__lshift__", _wrap___lshift__, METH_VARARGS, NULL},
	 { (char *)"new_Session", _wrap_new_Session, METH_VARARGS, NULL},
	 { (char *)"delete_Session", _wrap_delete_Session, METH_VARARGS, NULL},
	 { (char *)"Session_logon", _wrap_Session_logon, METH_VARARGS, NULL},
	 { (char *)"Session_logout", _wrap_Session_logout, METH_VARARGS, NULL},
	 { (char *)"Session_isEnabled", _wrap_Session_isEnabled, METH_VARARGS, NULL},
	 { (char *)"Session_sentLogon", _wrap_Session_sentLogon, METH_VARARGS, NULL},
	 { (char *)"Session_sentLogout", _wrap_Session_sentLogout, METH_VARARGS, NULL},
	 { (char *)"Session_receivedLogon", _wrap_Session_receivedLogon, METH_VARARGS, NULL},
	 { (char *)"Session_isLoggedOn", _wrap_Session_isLoggedOn, METH_VARARGS, NULL},
	 { (char *)"Session_reset", _wrap_Session_reset, METH_VARARGS, NULL},
	 { (char *)"Session_refresh", _wrap_Session_refresh, METH_VARARGS, NULL},
	 { (char *)"Session_setNextSenderMsgSeqNum", _wrap_Session_setNextSenderMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"Session_setNextTargetMsgSeqNum", _wrap_Session_setNextTargetMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"Session_getSessionID", _wrap_Session_getSessionID, METH_VARARGS, NULL},
	 { (char *)"Session_setDataDictionaryProvider", _wrap_Session_setDataDictionaryProvider, METH_VARARGS, NULL},
	 { (char *)"Session_getDataDictionaryProvider", _wrap_Session_getDataDictionaryProvider, METH_VARARGS, NULL},
	 { (char *)"Session_sendToTarget", _wrap_Session_sendToTarget, METH_VARARGS, NULL},
	 { (char *)"Session_getSessions", _wrap_Session_getSessions, METH_VARARGS, NULL},
	 { (char *)"Session_doesSessionExist", _wrap_Session_doesSessionExist, METH_VARARGS, NULL},
	 { (char *)"Session_lookupSession", _wrap_Session_lookupSession, METH_VARARGS, NULL},
	 { (char *)"Session_isSessionRegistered", _wrap_Session_isSessionRegistered, METH_VARARGS, NULL},
	 { (char *)"Session_registerSession", _wrap_Session_registerSession, METH_VARARGS, NULL},
	 { (char *)"Session_unregisterSession", _wrap_Session_unregisterSession, METH_VARARGS, NULL},
	 { (char *)"Session_numSessions", _wrap_Session_numSessions, METH_VARARGS, NULL},
	 { (char *)"Session_isSessionTime", _wrap_Session_isSessionTime, METH_VARARGS, NULL},
	 { (char *)"Session_isLogonTime", _wrap_Session_isLogonTime, METH_VARARGS, NULL},
	 { (char *)"Session_isInitiator", _wrap_Session_isInitiator, METH_VARARGS, NULL},
	 { (char *)"Session_isAcceptor", _wrap_Session_isAcceptor, METH_VARARGS, NULL},
	 { (char *)"Session_getLogonTime", _wrap_Session_getLogonTime, METH_VARARGS, NULL},
	 { (char *)"Session_setLogonTime", _wrap_Session_setLogonTime, METH_VARARGS, NULL},
	 { (char *)"Session_getSenderDefaultApplVerID", _wrap_Session_getSenderDefaultApplVerID, METH_VARARGS, NULL},
	 { (char *)"Session_setSenderDefaultApplVerID", _wrap_Session_setSenderDefaultApplVerID, METH_VARARGS, NULL},
	 { (char *)"Session_getTargetDefaultApplVerID", _wrap_Session_getTargetDefaultApplVerID, METH_VARARGS, NULL},
	 { (char *)"Session_setTargetDefaultApplVerID", _wrap_Session_setTargetDefaultApplVerID, METH_VARARGS, NULL},
	 { (char *)"Session_getSendRedundantResendRequests", _wrap_Session_getSendRedundantResendRequests, METH_VARARGS, NULL},
	 { (char *)"Session_setSendRedundantResendRequests", _wrap_Session_setSendRedundantResendRequests, METH_VARARGS, NULL},
	 { (char *)"Session_getCheckCompId", _wrap_Session_getCheckCompId, METH_VARARGS, NULL},
	 { (char *)"Session_setCheckCompId", _wrap_Session_setCheckCompId, METH_VARARGS, NULL},
	 { (char *)"Session_getCheckLatency", _wrap_Session_getCheckLatency, METH_VARARGS, NULL},
	 { (char *)"Session_setCheckLatency", _wrap_Session_setCheckLatency, METH_VARARGS, NULL},
	 { (char *)"Session_getMaxLatency", _wrap_Session_getMaxLatency, METH_VARARGS, NULL},
	 { (char *)"Session_setMaxLatency", _wrap_Session_setMaxLatency, METH_VARARGS, NULL},
	 { (char *)"Session_getLogonTimeout", _wrap_Session_getLogonTimeout, METH_VARARGS, NULL},
	 { (char *)"Session_setLogonTimeout", _wrap_Session_setLogonTimeout, METH_VARARGS, NULL},
	 { (char *)"Session_getLogoutTimeout", _wrap_Session_getLogoutTimeout, METH_VARARGS, NULL},
	 { (char *)"Session_setLogoutTimeout", _wrap_Session_setLogoutTimeout, METH_VARARGS, NULL},
	 { (char *)"Session_getResetOnLogon", _wrap_Session_getResetOnLogon, METH_VARARGS, NULL},
	 { (char *)"Session_setResetOnLogon", _wrap_Session_setResetOnLogon, METH_VARARGS, NULL},
	 { (char *)"Session_getResetOnLogout", _wrap_Session_getResetOnLogout, METH_VARARGS, NULL},
	 { (char *)"Session_setResetOnLogout", _wrap_Session_setResetOnLogout, METH_VARARGS, NULL},
	 { (char *)"Session_getResetOnDisconnect", _wrap_Session_getResetOnDisconnect, METH_VARARGS, NULL},
	 { (char *)"Session_setResetOnDisconnect", _wrap_Session_setResetOnDisconnect, METH_VARARGS, NULL},
	 { (char *)"Session_getRefreshOnLogon", _wrap_Session_getRefreshOnLogon, METH_VARARGS, NULL},
	 { (char *)"Session_setRefreshOnLogon", _wrap_Session_setRefreshOnLogon, METH_VARARGS, NULL},
	 { (char *)"Session_getMillisecondsInTimeStamp", _wrap_Session_getMillisecondsInTimeStamp, METH_VARARGS, NULL},
	 { (char *)"Session_setMillisecondsInTimeStamp", _wrap_Session_setMillisecondsInTimeStamp, METH_VARARGS, NULL},
	 { (char *)"Session_getPersistMessages", _wrap_Session_getPersistMessages, METH_VARARGS, NULL},
	 { (char *)"Session_setPersistMessages", _wrap_Session_setPersistMessages, METH_VARARGS, NULL},
	 { (char *)"Session_getValidateLengthAndChecksum", _wrap_Session_getValidateLengthAndChecksum, METH_VARARGS, NULL},
	 { (char *)"Session_setValidateLengthAndChecksum", _wrap_Session_setValidateLengthAndChecksum, METH_VARARGS, NULL},
	 { (char *)"Session_setResponder", _wrap_Session_setResponder, METH_VARARGS, NULL},
	 { (char *)"Session_send", _wrap_Session_send, METH_VARARGS, NULL},
	 { (char *)"Session_next", _wrap_Session_next, METH_VARARGS, NULL},
	 { (char *)"Session_disconnect", _wrap_Session_disconnect, METH_VARARGS, NULL},
	 { (char *)"Session_getExpectedSenderNum", _wrap_Session_getExpectedSenderNum, METH_VARARGS, NULL},
	 { (char *)"Session_getExpectedTargetNum", _wrap_Session_getExpectedTargetNum, METH_VARARGS, NULL},
	 { (char *)"Session_getLog", _wrap_Session_getLog, METH_VARARGS, NULL},
	 { (char *)"Session_getStore", _wrap_Session_getStore, METH_VARARGS, NULL},
	 { (char *)"Session_swigregister", Session_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_LogFactory", _wrap_delete_LogFactory, METH_VARARGS, NULL},
	 { (char *)"LogFactory_create", _wrap_LogFactory_create, METH_VARARGS, NULL},
	 { (char *)"LogFactory_destroy", _wrap_LogFactory_destroy, METH_VARARGS, NULL},
	 { (char *)"LogFactory_swigregister", LogFactory_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ScreenLogFactory", _wrap_new_ScreenLogFactory, METH_VARARGS, NULL},
	 { (char *)"ScreenLogFactory_create", _wrap_ScreenLogFactory_create, METH_VARARGS, NULL},
	 { (char *)"ScreenLogFactory_destroy", _wrap_ScreenLogFactory_destroy, METH_VARARGS, NULL},
	 { (char *)"delete_ScreenLogFactory", _wrap_delete_ScreenLogFactory, METH_VARARGS, NULL},
	 { (char *)"ScreenLogFactory_swigregister", ScreenLogFactory_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_Log", _wrap_delete_Log, METH_VARARGS, NULL},
	 { (char *)"Log_clear", _wrap_Log_clear, METH_VARARGS, NULL},
	 { (char *)"Log_backup", _wrap_Log_backup, METH_VARARGS, NULL},
	 { (char *)"Log_onIncoming", _wrap_Log_onIncoming, METH_VARARGS, NULL},
	 { (char *)"Log_onOutgoing", _wrap_Log_onOutgoing, METH_VARARGS, NULL},
	 { (char *)"Log_onEvent", _wrap_Log_onEvent, METH_VARARGS, NULL},
	 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
	 { (char *)"NullLog_clear", _wrap_NullLog_clear, METH_VARARGS, NULL},
	 { (char *)"NullLog_backup", _wrap_NullLog_backup, METH_VARARGS, NULL},
	 { (char *)"NullLog_onIncoming", _wrap_NullLog_onIncoming, METH_VARARGS, NULL},
	 { (char *)"NullLog_onOutgoing", _wrap_NullLog_onOutgoing, METH_VARARGS, NULL},
	 { (char *)"NullLog_onEvent", _wrap_NullLog_onEvent, METH_VARARGS, NULL},
	 { (char *)"new_NullLog", _wrap_new_NullLog, METH_VARARGS, NULL},
	 { (char *)"delete_NullLog", _wrap_delete_NullLog, METH_VARARGS, NULL},
	 { (char *)"NullLog_swigregister", NullLog_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ScreenLog", _wrap_new_ScreenLog, METH_VARARGS, NULL},
	 { (char *)"ScreenLog_clear", _wrap_ScreenLog_clear, METH_VARARGS, NULL},
	 { (char *)"ScreenLog_backup", _wrap_ScreenLog_backup, METH_VARARGS, NULL},
	 { (char *)"ScreenLog_onIncoming", _wrap_ScreenLog_onIncoming, METH_VARARGS, NULL},
	 { (char *)"ScreenLog_onOutgoing", _wrap_ScreenLog_onOutgoing, METH_VARARGS, NULL},
	 { (char *)"ScreenLog_onEvent", _wrap_ScreenLog_onEvent, METH_VARARGS, NULL},
	 { (char *)"ScreenLog_getMillisecondsInTimeStamp", _wrap_ScreenLog_getMillisecondsInTimeStamp, METH_VARARGS, NULL},
	 { (char *)"ScreenLog_setMillisecondsInTimeStamp", _wrap_ScreenLog_setMillisecondsInTimeStamp, METH_VARARGS, NULL},
	 { (char *)"delete_ScreenLog", _wrap_delete_ScreenLog, METH_VARARGS, NULL},
	 { (char *)"ScreenLog_swigregister", ScreenLog_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FileLogFactory", _wrap_new_FileLogFactory, METH_VARARGS, NULL},
	 { (char *)"FileLogFactory_create", _wrap_FileLogFactory_create, METH_VARARGS, NULL},
	 { (char *)"FileLogFactory_destroy", _wrap_FileLogFactory_destroy, METH_VARARGS, NULL},
	 { (char *)"delete_FileLogFactory", _wrap_delete_FileLogFactory, METH_VARARGS, NULL},
	 { (char *)"FileLogFactory_swigregister", FileLogFactory_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FileLog", _wrap_new_FileLog, METH_VARARGS, NULL},
	 { (char *)"delete_FileLog", _wrap_delete_FileLog, METH_VARARGS, NULL},
	 { (char *)"FileLog_clear", _wrap_FileLog_clear, METH_VARARGS, NULL},
	 { (char *)"FileLog_backup", _wrap_FileLog_backup, METH_VARARGS, NULL},
	 { (char *)"FileLog_onIncoming", _wrap_FileLog_onIncoming, METH_VARARGS, NULL},
	 { (char *)"FileLog_onOutgoing", _wrap_FileLog_onOutgoing, METH_VARARGS, NULL},
	 { (char *)"FileLog_onEvent", _wrap_FileLog_onEvent, METH_VARARGS, NULL},
	 { (char *)"FileLog_getMillisecondsInTimeStamp", _wrap_FileLog_getMillisecondsInTimeStamp, METH_VARARGS, NULL},
	 { (char *)"FileLog_setMillisecondsInTimeStamp", _wrap_FileLog_setMillisecondsInTimeStamp, METH_VARARGS, NULL},
	 { (char *)"FileLog_swigregister", FileLog_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_MessageStoreFactory", _wrap_delete_MessageStoreFactory, METH_VARARGS, NULL},
	 { (char *)"MessageStoreFactory_create", _wrap_MessageStoreFactory_create, METH_VARARGS, NULL},
	 { (char *)"MessageStoreFactory_destroy", _wrap_MessageStoreFactory_destroy, METH_VARARGS, NULL},
	 { (char *)"MessageStoreFactory_swigregister", MessageStoreFactory_swigregister, METH_VARARGS, NULL},
	 { (char *)"MemoryStoreFactory_create", _wrap_MemoryStoreFactory_create, METH_VARARGS, NULL},
	 { (char *)"MemoryStoreFactory_destroy", _wrap_MemoryStoreFactory_destroy, METH_VARARGS, NULL},
	 { (char *)"new_MemoryStoreFactory", _wrap_new_MemoryStoreFactory, METH_VARARGS, NULL},
	 { (char *)"delete_MemoryStoreFactory", _wrap_delete_MemoryStoreFactory, METH_VARARGS, NULL},
	 { (char *)"MemoryStoreFactory_swigregister", MemoryStoreFactory_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_MessageStore", _wrap_delete_MessageStore, METH_VARARGS, NULL},
	 { (char *)"MessageStore_set", _wrap_MessageStore_set, METH_VARARGS, NULL},
	 { (char *)"MessageStore_get", _wrap_MessageStore_get, METH_VARARGS, NULL},
	 { (char *)"MessageStore_getNextSenderMsgSeqNum", _wrap_MessageStore_getNextSenderMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MessageStore_getNextTargetMsgSeqNum", _wrap_MessageStore_getNextTargetMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MessageStore_setNextSenderMsgSeqNum", _wrap_MessageStore_setNextSenderMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MessageStore_setNextTargetMsgSeqNum", _wrap_MessageStore_setNextTargetMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MessageStore_incrNextSenderMsgSeqNum", _wrap_MessageStore_incrNextSenderMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MessageStore_incrNextTargetMsgSeqNum", _wrap_MessageStore_incrNextTargetMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MessageStore_getCreationTime", _wrap_MessageStore_getCreationTime, METH_VARARGS, NULL},
	 { (char *)"MessageStore_reset", _wrap_MessageStore_reset, METH_VARARGS, NULL},
	 { (char *)"MessageStore_refresh", _wrap_MessageStore_refresh, METH_VARARGS, NULL},
	 { (char *)"MessageStore_swigregister", MessageStore_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MemoryStore", _wrap_new_MemoryStore, METH_VARARGS, NULL},
	 { (char *)"MemoryStore_set", _wrap_MemoryStore_set, METH_VARARGS, NULL},
	 { (char *)"MemoryStore_get", _wrap_MemoryStore_get, METH_VARARGS, NULL},
	 { (char *)"MemoryStore_getNextSenderMsgSeqNum", _wrap_MemoryStore_getNextSenderMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MemoryStore_getNextTargetMsgSeqNum", _wrap_MemoryStore_getNextTargetMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MemoryStore_setNextSenderMsgSeqNum", _wrap_MemoryStore_setNextSenderMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MemoryStore_setNextTargetMsgSeqNum", _wrap_MemoryStore_setNextTargetMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MemoryStore_incrNextSenderMsgSeqNum", _wrap_MemoryStore_incrNextSenderMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MemoryStore_incrNextTargetMsgSeqNum", _wrap_MemoryStore_incrNextTargetMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MemoryStore_setCreationTime", _wrap_MemoryStore_setCreationTime, METH_VARARGS, NULL},
	 { (char *)"MemoryStore_getCreationTime", _wrap_MemoryStore_getCreationTime, METH_VARARGS, NULL},
	 { (char *)"MemoryStore_reset", _wrap_MemoryStore_reset, METH_VARARGS, NULL},
	 { (char *)"MemoryStore_refresh", _wrap_MemoryStore_refresh, METH_VARARGS, NULL},
	 { (char *)"delete_MemoryStore", _wrap_delete_MemoryStore, METH_VARARGS, NULL},
	 { (char *)"MemoryStore_swigregister", MemoryStore_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MessageStoreFactoryExceptionWrapper", _wrap_new_MessageStoreFactoryExceptionWrapper, METH_VARARGS, NULL},
	 { (char *)"MessageStoreFactoryExceptionWrapper_create", _wrap_MessageStoreFactoryExceptionWrapper_create, METH_VARARGS, NULL},
	 { (char *)"MessageStoreFactoryExceptionWrapper_destroy", _wrap_MessageStoreFactoryExceptionWrapper_destroy, METH_VARARGS, NULL},
	 { (char *)"delete_MessageStoreFactoryExceptionWrapper", _wrap_delete_MessageStoreFactoryExceptionWrapper, METH_VARARGS, NULL},
	 { (char *)"MessageStoreFactoryExceptionWrapper_swigregister", MessageStoreFactoryExceptionWrapper_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MessageStoreExceptionWrapper", _wrap_new_MessageStoreExceptionWrapper, METH_VARARGS, NULL},
	 { (char *)"delete_MessageStoreExceptionWrapper", _wrap_delete_MessageStoreExceptionWrapper, METH_VARARGS, NULL},
	 { (char *)"MessageStoreExceptionWrapper_set", _wrap_MessageStoreExceptionWrapper_set, METH_VARARGS, NULL},
	 { (char *)"MessageStoreExceptionWrapper_get", _wrap_MessageStoreExceptionWrapper_get, METH_VARARGS, NULL},
	 { (char *)"MessageStoreExceptionWrapper_getNextSenderMsgSeqNum", _wrap_MessageStoreExceptionWrapper_getNextSenderMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MessageStoreExceptionWrapper_getNextTargetMsgSeqNum", _wrap_MessageStoreExceptionWrapper_getNextTargetMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MessageStoreExceptionWrapper_setNextSenderMsgSeqNum", _wrap_MessageStoreExceptionWrapper_setNextSenderMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MessageStoreExceptionWrapper_setNextTargetMsgSeqNum", _wrap_MessageStoreExceptionWrapper_setNextTargetMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum", _wrap_MessageStoreExceptionWrapper_incrNextSenderMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum", _wrap_MessageStoreExceptionWrapper_incrNextTargetMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"MessageStoreExceptionWrapper_getCreationTime", _wrap_MessageStoreExceptionWrapper_getCreationTime, METH_VARARGS, NULL},
	 { (char *)"MessageStoreExceptionWrapper_reset", _wrap_MessageStoreExceptionWrapper_reset, METH_VARARGS, NULL},
	 { (char *)"MessageStoreExceptionWrapper_refresh", _wrap_MessageStoreExceptionWrapper_refresh, METH_VARARGS, NULL},
	 { (char *)"MessageStoreExceptionWrapper_swigregister", MessageStoreExceptionWrapper_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FileStoreFactory", _wrap_new_FileStoreFactory, METH_VARARGS, NULL},
	 { (char *)"FileStoreFactory_create", _wrap_FileStoreFactory_create, METH_VARARGS, NULL},
	 { (char *)"FileStoreFactory_destroy", _wrap_FileStoreFactory_destroy, METH_VARARGS, NULL},
	 { (char *)"delete_FileStoreFactory", _wrap_delete_FileStoreFactory, METH_VARARGS, NULL},
	 { (char *)"FileStoreFactory_swigregister", FileStoreFactory_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FileStore", _wrap_new_FileStore, METH_VARARGS, NULL},
	 { (char *)"delete_FileStore", _wrap_delete_FileStore, METH_VARARGS, NULL},
	 { (char *)"FileStore_set", _wrap_FileStore_set, METH_VARARGS, NULL},
	 { (char *)"FileStore_get", _wrap_FileStore_get, METH_VARARGS, NULL},
	 { (char *)"FileStore_getNextSenderMsgSeqNum", _wrap_FileStore_getNextSenderMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"FileStore_getNextTargetMsgSeqNum", _wrap_FileStore_getNextTargetMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"FileStore_setNextSenderMsgSeqNum", _wrap_FileStore_setNextSenderMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"FileStore_setNextTargetMsgSeqNum", _wrap_FileStore_setNextTargetMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"FileStore_incrNextSenderMsgSeqNum", _wrap_FileStore_incrNextSenderMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"FileStore_incrNextTargetMsgSeqNum", _wrap_FileStore_incrNextTargetMsgSeqNum, METH_VARARGS, NULL},
	 { (char *)"FileStore_getCreationTime", _wrap_FileStore_getCreationTime, METH_VARARGS, NULL},
	 { (char *)"FileStore_reset", _wrap_FileStore_reset, METH_VARARGS, NULL},
	 { (char *)"FileStore_refresh", _wrap_FileStore_refresh, METH_VARARGS, NULL},
	 { (char *)"FileStore_swigregister", FileStore_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_Application", _wrap_delete_Application, METH_VARARGS, NULL},
	 { (char *)"Application_onCreate", _wrap_Application_onCreate, METH_VARARGS, NULL},
	 { (char *)"Application_onLogon", _wrap_Application_onLogon, METH_VARARGS, NULL},
	 { (char *)"Application_onLogout", _wrap_Application_onLogout, METH_VARARGS, NULL},
	 { (char *)"Application_toAdmin", _wrap_Application_toAdmin, METH_VARARGS, NULL},
	 { (char *)"Application_toApp", _wrap_Application_toApp, METH_VARARGS, NULL},
	 { (char *)"Application_fromAdmin", _wrap_Application_fromAdmin, METH_VARARGS, NULL},
	 { (char *)"Application_fromApp", _wrap_Application_fromApp, METH_VARARGS, NULL},
	 { (char *)"new_Application", _wrap_new_Application, METH_VARARGS, NULL},
	 { (char *)"disown_Application", _wrap_disown_Application, METH_VARARGS, NULL},
	 { (char *)"Application_swigregister", Application_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SynchronizedApplication", _wrap_new_SynchronizedApplication, METH_VARARGS, NULL},
	 { (char *)"SynchronizedApplication_onCreate", _wrap_SynchronizedApplication_onCreate, METH_VARARGS, NULL},
	 { (char *)"SynchronizedApplication_onLogon", _wrap_SynchronizedApplication_onLogon, METH_VARARGS, NULL},
	 { (char *)"SynchronizedApplication_onLogout", _wrap_SynchronizedApplication_onLogout, METH_VARARGS, NULL},
	 { (char *)"SynchronizedApplication_toAdmin", _wrap_SynchronizedApplication_toAdmin, METH_VARARGS, NULL},
	 { (char *)"SynchronizedApplication_toApp", _wrap_SynchronizedApplication_toApp, METH_VARARGS, NULL},
	 { (char *)"SynchronizedApplication_fromAdmin", _wrap_SynchronizedApplication_fromAdmin, METH_VARARGS, NULL},
	 { (char *)"SynchronizedApplication_fromApp", _wrap_SynchronizedApplication_fromApp, METH_VARARGS, NULL},
	 { (char *)"SynchronizedApplication_m_mutex_set", _wrap_SynchronizedApplication_m_mutex_set, METH_VARARGS, NULL},
	 { (char *)"SynchronizedApplication_m_mutex_get", _wrap_SynchronizedApplication_m_mutex_get, METH_VARARGS, NULL},
	 { (char *)"SynchronizedApplication_app", _wrap_SynchronizedApplication_app, METH_VARARGS, NULL},
	 { (char *)"SynchronizedApplication_m_app_set", _wrap_SynchronizedApplication_m_app_set, METH_VARARGS, NULL},
	 { (char *)"SynchronizedApplication_m_app_get", _wrap_SynchronizedApplication_m_app_get, METH_VARARGS, NULL},
	 { (char *)"delete_SynchronizedApplication", _wrap_delete_SynchronizedApplication, METH_VARARGS, NULL},
	 { (char *)"SynchronizedApplication_swigregister", SynchronizedApplication_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NullApplication", _wrap_new_NullApplication, METH_VARARGS, NULL},
	 { (char *)"delete_NullApplication", _wrap_delete_NullApplication, METH_VARARGS, NULL},
	 { (char *)"NullApplication_swigregister", NullApplication_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_Initiator", _wrap_delete_Initiator, METH_VARARGS, NULL},
	 { (char *)"Initiator_start", _wrap_Initiator_start, METH_VARARGS, NULL},
	 { (char *)"Initiator_block", _wrap_Initiator_block, METH_VARARGS, NULL},
	 { (char *)"Initiator_poll", _wrap_Initiator_poll, METH_VARARGS, NULL},
	 { (char *)"Initiator_stop", _wrap_Initiator_stop, METH_VARARGS, NULL},
	 { (char *)"Initiator_isLoggedOn", _wrap_Initiator_isLoggedOn, METH_VARARGS, NULL},
	 { (char *)"Initiator_getSessions", _wrap_Initiator_getSessions, METH_VARARGS, NULL},
	 { (char *)"Initiator_getSession", _wrap_Initiator_getSession, METH_VARARGS, NULL},
	 { (char *)"Initiator_getSessionSettings", _wrap_Initiator_getSessionSettings, METH_VARARGS, NULL},
	 { (char *)"Initiator_has", _wrap_Initiator_has, METH_VARARGS, NULL},
	 { (char *)"Initiator_isStopped", _wrap_Initiator_isStopped, METH_VARARGS, NULL},
	 { (char *)"Initiator_getApplication", _wrap_Initiator_getApplication, METH_VARARGS, NULL},
	 { (char *)"Initiator_getMessageStoreFactory", _wrap_Initiator_getMessageStoreFactory, METH_VARARGS, NULL},
	 { (char *)"Initiator_getLog", _wrap_Initiator_getLog, METH_VARARGS, NULL},
	 { (char *)"Initiator_swigregister", Initiator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SocketInitiatorBase", _wrap_new_SocketInitiatorBase, METH_VARARGS, NULL},
	 { (char *)"delete_SocketInitiatorBase", _wrap_delete_SocketInitiatorBase, METH_VARARGS, NULL},
	 { (char *)"SocketInitiatorBase_swigregister", SocketInitiatorBase_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_Acceptor", _wrap_delete_Acceptor, METH_VARARGS, NULL},
	 { (char *)"Acceptor_getLog", _wrap_Acceptor_getLog, METH_VARARGS, NULL},
	 { (char *)"Acceptor_start", _wrap_Acceptor_start, METH_VARARGS, NULL},
	 { (char *)"Acceptor_block", _wrap_Acceptor_block, METH_VARARGS, NULL},
	 { (char *)"Acceptor_poll", _wrap_Acceptor_poll, METH_VARARGS, NULL},
	 { (char *)"Acceptor_stop", _wrap_Acceptor_stop, METH_VARARGS, NULL},
	 { (char *)"Acceptor_isLoggedOn", _wrap_Acceptor_isLoggedOn, METH_VARARGS, NULL},
	 { (char *)"Acceptor_getSessions", _wrap_Acceptor_getSessions, METH_VARARGS, NULL},
	 { (char *)"Acceptor_getSession", _wrap_Acceptor_getSession, METH_VARARGS, NULL},
	 { (char *)"Acceptor_getSessionSettings", _wrap_Acceptor_getSessionSettings, METH_VARARGS, NULL},
	 { (char *)"Acceptor_has", _wrap_Acceptor_has, METH_VARARGS, NULL},
	 { (char *)"Acceptor_isStopped", _wrap_Acceptor_isStopped, METH_VARARGS, NULL},
	 { (char *)"Acceptor_getApplication", _wrap_Acceptor_getApplication, METH_VARARGS, NULL},
	 { (char *)"Acceptor_getMessageStoreFactory", _wrap_Acceptor_getMessageStoreFactory, METH_VARARGS, NULL},
	 { (char *)"Acceptor_swigregister", Acceptor_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SocketAcceptorBase", _wrap_new_SocketAcceptorBase, METH_VARARGS, NULL},
	 { (char *)"delete_SocketAcceptorBase", _wrap_delete_SocketAcceptorBase, METH_VARARGS, NULL},
	 { (char *)"SocketAcceptorBase_swigregister", SocketAcceptorBase_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DataDictionary", _wrap_new_DataDictionary, METH_VARARGS, NULL},
	 { (char *)"delete_DataDictionary", _wrap_delete_DataDictionary, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_readFromURL", _wrap_DataDictionary_readFromURL, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_readFromDocument", _wrap_DataDictionary_readFromDocument, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_readFromStream", _wrap_DataDictionary_readFromStream, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_getOrderedFields", _wrap_DataDictionary_getOrderedFields, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_setVersion", _wrap_DataDictionary_setVersion, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_getVersion", _wrap_DataDictionary_getVersion, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_addField", _wrap_DataDictionary_addField, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_addFieldName", _wrap_DataDictionary_addFieldName, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_getFieldName", _wrap_DataDictionary_getFieldName, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_getFieldTag", _wrap_DataDictionary_getFieldTag, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_addValueName", _wrap_DataDictionary_addValueName, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_getValueName", _wrap_DataDictionary_getValueName, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_isField", _wrap_DataDictionary_isField, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_addMsgType", _wrap_DataDictionary_addMsgType, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_isMsgType", _wrap_DataDictionary_isMsgType, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_addMsgField", _wrap_DataDictionary_addMsgField, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_isMsgField", _wrap_DataDictionary_isMsgField, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_addHeaderField", _wrap_DataDictionary_addHeaderField, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_isHeaderField", _wrap_DataDictionary_isHeaderField, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_addTrailerField", _wrap_DataDictionary_addTrailerField, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_isTrailerField", _wrap_DataDictionary_isTrailerField, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_addFieldType", _wrap_DataDictionary_addFieldType, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_getFieldType", _wrap_DataDictionary_getFieldType, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_addRequiredField", _wrap_DataDictionary_addRequiredField, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_isRequiredField", _wrap_DataDictionary_isRequiredField, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_addFieldValue", _wrap_DataDictionary_addFieldValue, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_hasFieldValue", _wrap_DataDictionary_hasFieldValue, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_isFieldValue", _wrap_DataDictionary_isFieldValue, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_addGroup", _wrap_DataDictionary_addGroup, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_isGroup", _wrap_DataDictionary_isGroup, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_getGroup", _wrap_DataDictionary_getGroup, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_isDataField", _wrap_DataDictionary_isDataField, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_isMultipleValueField", _wrap_DataDictionary_isMultipleValueField, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_checkFieldsOutOfOrder", _wrap_DataDictionary_checkFieldsOutOfOrder, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_checkFieldsHaveValues", _wrap_DataDictionary_checkFieldsHaveValues, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_checkUserDefinedFields", _wrap_DataDictionary_checkUserDefinedFields, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_validate", _wrap_DataDictionary_validate, METH_VARARGS, NULL},
	 { (char *)"DataDictionary_swigregister", DataDictionary_swigregister, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_FIX__CheckSumTo_p_FIX__CheckSumField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CheckSumField *)  ((FIX::CheckSum *) x));
}
static void *_p_FIX__NullLogTo_p_FIX__Log(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Log *)  ((FIX::NullLog *) x));
}
static void *_p_FIX__FileLogTo_p_FIX__Log(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Log *)  ((FIX::FileLog *) x));
}
static void *_p_FIX__ScreenLogTo_p_FIX__Log(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Log *)  ((FIX::ScreenLog *) x));
}
static void *_p_IntArrayTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int *)  ((IntArray *) x));
}
static void *_p_FIX__SocketInitiatorTo_p_FIX__Initiator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Initiator *)  ((FIX::SocketInitiator *) x));
}
static void *_p_FIX__SocketAcceptorTo_p_FIX__Acceptor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Acceptor *)  ((FIX::SocketAcceptor *) x));
}
static void *_p_FIX__MDEntryTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MDEntryType *) x));
}
static void *_p_FIX__RegistStatusTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::RegistStatus *) x));
}
static void *_p_FIX__OrdStatusTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OrdStatus *) x));
}
static void *_p_FIX__MatchStatusTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MatchStatus *) x));
}
static void *_p_FIX__BidTradeTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::BidTradeType *) x));
}
static void *_p_FIX__FundRenewWaivTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::FundRenewWaiv *) x));
}
static void *_p_FIX__TradeTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TradeType *) x));
}
static void *_p_FIX__OpenCloseTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OpenClose *) x));
}
static void *_p_FIX__UrgencyTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::Urgency *) x));
}
static void *_p_FIX__IOIOthSvcTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::IOIOthSvc *) x));
}
static void *_p_FIX__EmailTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::EmailType *) x));
}
static void *_p_FIX__IOITransTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::IOITransType *) x));
}
static void *_p_FIX__AllocTransTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::AllocTransType *) x));
}
static void *_p_FIX__ExecTransTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ExecTransType *) x));
}
static void *_p_FIX__BidRequestTransTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::BidRequestTransType *) x));
}
static void *_p_FIX__RegistTransTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::RegistTransType *) x));
}
static void *_p_FIX__SettlInstTransTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlInstTransType *) x));
}
static void *_p_FIX__ListExecInstTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ListExecInstType *) x));
}
static void *_p_FIX__DlvyInstTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DlvyInstType *) x));
}
static void *_p_FIX__SettlObligTransTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlObligTransType *) x));
}
static void *_p_FIX__QuoteQualifierTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::QuoteQualifier *) x));
}
static void *_p_FIX__IOIQualifierTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::IOIQualifier *) x));
}
static void *_p_FIX__SettlInstModeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlInstMode *) x));
}
static void *_p_FIX__ExecTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ExecType *) x));
}
static void *_p_FIX__DerivativeExerciseStyleTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeExerciseStyle *) x));
}
static void *_p_FIX__TimeInForceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TimeInForce *) x));
}
static void *_p_FIX__TriggerTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerType *) x));
}
static void *_p_FIX__OwnershipTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OwnershipType *) x));
}
static void *_p_FIX__AssignmentMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::AssignmentMethod *) x));
}
static void *_p_FIX__SettlMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlMethod *) x));
}
static void *_p_FIX__DerivativeInstrmtAssignmentMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeInstrmtAssignmentMethod *) x));
}
static void *_p_FIX__InstrmtAssignmentMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::InstrmtAssignmentMethod *) x));
}
static void *_p_FIX__DerivativeSettlMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeSettlMethod *) x));
}
static void *_p_FIX__MDReqRejReasonTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MDReqRejReason *) x));
}
static void *_p_FIX__BookingUnitTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::BookingUnit *) x));
}
static void *_p_FIX__SettlCurrFxRateCalcTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlCurrFxRateCalc *) x));
}
static void *_p_FIX__UnderlyingFXRateCalcTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingFXRateCalc *) x));
}
static void *_p_FIX__TriggerActionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerAction *) x));
}
static void *_p_FIX__DiscretionInstTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DiscretionInst *) x));
}
static void *_p_FIX__ExecInstValueTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ExecInstValue *) x));
}
static void *_p_FIX__TriggerPriceTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerPriceType *) x));
}
static void *_p_FIX__ExecPriceTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ExecPriceType *) x));
}
static void *_p_FIX__SettlObligSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlObligSource *) x));
}
static void *_p_FIX__MassCancelRequestTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MassCancelRequestType *) x));
}
static void *_p_FIX__SubscriptionRequestTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SubscriptionRequestType *) x));
}
static void *_p_FIX__TriggerPriceTypeScopeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerPriceTypeScope *) x));
}
static void *_p_FIX__ProcessCodeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ProcessCode *) x));
}
static void *_p_FIX__LotTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::LotType *) x));
}
static void *_p_FIX__LegSideTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::LegSide *) x));
}
static void *_p_FIX__RoundingDirectionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::RoundingDirection *) x));
}
static void *_p_FIX__TriggerPriceDirectionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerPriceDirection *) x));
}
static void *_p_FIX__TickDirectionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TickDirection *) x));
}
static void *_p_FIX__MsgDirectionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MsgDirection *) x));
}
static void *_p_FIX__HaltReasonCharTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::HaltReasonChar *) x));
}
static void *_p_FIX__OrderCapacityTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OrderCapacity *) x));
}
static void *_p_FIX__DealingCapacityTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DealingCapacity *) x));
}
static void *_p_FIX__LastCapacityTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::LastCapacity *) x));
}
static void *_p_FIX__PriceProtectionScopeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::PriceProtectionScope *) x));
}
static void *_p_FIX__BasisPxTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::BasisPxType *) x));
}
static void *_p_FIX__PositionEffectTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::PositionEffect *) x));
}
static void *_p_FIX__LegPositionEffectTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::LegPositionEffect *) x));
}
static void *_p_FIX__AllocPositionEffectTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::AllocPositionEffect *) x));
}
static void *_p_FIX__VenueTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::VenueType *) x));
}
static void *_p_FIX__HandlInstTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::HandlInst *) x));
}
static void *_p_FIX__MoneyLaunderingStatusTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MoneyLaunderingStatus *) x));
}
static void *_p_FIX__ExecAckStatusTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ExecAckStatus *) x));
}
static void *_p_FIX__CxlRejResponseToTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::CxlRejResponseTo *) x));
}
static void *_p_FIX__DisplayWhenTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DisplayWhen *) x));
}
static void *_p_FIX__OrderCategoryTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OrderCategory *) x));
}
static void *_p_FIX__MultiLegReportingTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MultiLegReportingType *) x));
}
static void *_p_FIX__CxlTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::CxlType *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingInstrumentPartyIDSource *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::UndlyInstrumentPartyIDSource *) x));
}
static void *_p_FIX__Nested4PartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::Nested4PartyIDSource *) x));
}
static void *_p_FIX__RootPartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::RootPartyIDSource *) x));
}
static void *_p_FIX__ExDestinationIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ExDestinationIDSource *) x));
}
static void *_p_FIX__Nested3PartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::Nested3PartyIDSource *) x));
}
static void *_p_FIX__TargetPartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TargetPartyIDSource *) x));
}
static void *_p_FIX__InstrumentPartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::InstrumentPartyIDSource *) x));
}
static void *_p_FIX__SettlInstSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlInstSource *) x));
}
static void *_p_FIX__NestedPartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::NestedPartyIDSource *) x));
}
static void *_p_FIX__CommTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::CommType *) x));
}
static void *_p_FIX__PartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::PartyIDSource *) x));
}
static void *_p_FIX__SettlPartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlPartyIDSource *) x));
}
static void *_p_FIX__RefOrderIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::RefOrderIDSource *) x));
}
static void *_p_FIX__Nested2PartyIDSourceTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::Nested2PartyIDSource *) x));
}
static void *_p_FIX__MassCancelResponseTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MassCancelResponse *) x));
}
static void *_p_FIX__BenchmarkTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::Benchmark *) x));
}
static void *_p_FIX__TriggerOrderTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TriggerOrderType *) x));
}
static void *_p_FIX__LegSettlTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::LegSettlType *) x));
}
static void *_p_FIX__LegSettlmntTypTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::LegSettlmntTyp *) x));
}
static void *_p_FIX__SettlmntTypTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SettlmntTyp *) x));
}
static void *_p_FIX__PreallocMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::PreallocMethod *) x));
}
static void *_p_FIX__ExerciseMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ExerciseMethod *) x));
}
static void *_p_FIX__AsOfIndicatorTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::AsOfIndicator *) x));
}
static void *_p_FIX__DisplayMethodTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DisplayMethod *) x));
}
static void *_p_FIX__OrigTradeHandlingInstrTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OrigTradeHandlingInstr *) x));
}
static void *_p_FIX__TradeHandlingInstrTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TradeHandlingInstr *) x));
}
static void *_p_FIX__DeleteReasonTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DeleteReason *) x));
}
static void *_p_FIX__DKReasonTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DKReason *) x));
}
static void *_p_FIX__CancellationRightsTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::CancellationRights *) x));
}
static void *_p_FIX__CashMarginTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::CashMargin *) x));
}
static void *_p_FIX__Rule80ATo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::Rule80A *) x));
}
static void *_p_FIX__DayBookingInstTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DayBookingInst *) x));
}
static void *_p_FIX__AdvSideTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::AdvSide *) x));
}
static void *_p_FIX__DerivativeOptAttributeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::DerivativeOptAttribute *) x));
}
static void *_p_FIX__UnderlyingLegOptAttributeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingLegOptAttribute *) x));
}
static void *_p_FIX__OptAttributeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OptAttribute *) x));
}
static void *_p_FIX__UnderlyingOptAttributeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::UnderlyingOptAttribute *) x));
}
static void *_p_FIX__IOIQltyIndTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::IOIQltyInd *) x));
}
static void *_p_FIX__LegOptAttributeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::LegOptAttribute *) x));
}
static void *_p_FIX__SideTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::Side *) x));
}
static void *_p_FIX__TradSesUpdateActionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::TradSesUpdateAction *) x));
}
static void *_p_FIX__SecurityUpdateActionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::SecurityUpdateAction *) x));
}
static void *_p_FIX__ListUpdateActionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::ListUpdateAction *) x));
}
static void *_p_FIX__OrdTypeTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::OrdType *) x));
}
static void *_p_FIX__MarketUpdateActionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MarketUpdateAction *) x));
}
static void *_p_FIX__MDUpdateActionTo_p_FIX__CharField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::CharField *)  ((FIX::MDUpdateAction *) x));
}
static void *_p_FIX__GroupTo_p_FIX__FieldMap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldMap *)  ((FIX::Group *) x));
}
static void *_p_FIX__HeaderTo_p_FIX__FieldMap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldMap *)  ((FIX::Header *) x));
}
static void *_p_FIX__TrailerTo_p_FIX__FieldMap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldMap *)  ((FIX::Trailer *) x));
}
static void *_p_FIX__MessageTo_p_FIX__FieldMap(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldMap *)  ((FIX::Message *) x));
}
static void *_p_FIX__CFICodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CFICode *) x));
}
static void *_p_FIX__UnderlyingCFICodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCFICode *) x));
}
static void *_p_FIX__DerivativeCFICodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeCFICode *) x));
}
static void *_p_FIX__LegCFICodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCFICode *) x));
}
static void *_p_FIX__MaturityMonthYearFormatTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaturityMonthYearFormat *) x));
}
static void *_p_FIX__UnderlyingLegCFICodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegCFICode *) x));
}
static void *_p_FIX__StartCashTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StartCash *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingPriceUnitOfMeasure *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingUnitOfMeasure *) x));
}
static void *_p_FIX__LegUnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegUnitOfMeasure *) x));
}
static void *_p_FIX__PriceUnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PriceUnitOfMeasure *) x));
}
static void *_p_FIX__UnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnitOfMeasure *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegPriceUnitOfMeasure *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeUnitOfMeasure *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativePriceUnitOfMeasure *) x));
}
static void *_p_FIX__OrigTradeIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigTradeID *) x));
}
static void *_p_FIX__FirmTradeIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FirmTradeID *) x));
}
static void *_p_FIX__SecondaryFirmTradeIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryFirmTradeID *) x));
}
static void *_p_FIX__TradeIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeID *) x));
}
static void *_p_FIX__SecondaryTradeIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryTradeID *) x));
}
static void *_p_FIX__OrigSecondaryTradeIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigSecondaryTradeID *) x));
}
static void *_p_FIX__UnderlyingSecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityType *) x));
}
static void *_p_FIX__SecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityType *) x));
}
static void *_p_FIX__RepoCollateralSecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RepoCollateralSecurityType *) x));
}
static void *_p_FIX__LegRepoCollateralSecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegRepoCollateralSecurityType *) x));
}
static void *_p_FIX__ExpirationQtyTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExpirationQtyType *) x));
}
static void *_p_FIX__LegSecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityType *) x));
}
static void *_p_FIX__QuantityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuantityType *) x));
}
static void *_p_FIX__DerivativeSecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityType *) x));
}
static void *_p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingRepoCollateralSecurityType *) x));
}
static void *_p_FIX__QtyTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QtyType *) x));
}
static void *_p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityType *) x));
}
static void *_p_FIX__AccountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Account *) x));
}
static void *_p_FIX__ClearingAccountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingAccount *) x));
}
static void *_p_FIX__LegAllocAccountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocAccount *) x));
}
static void *_p_FIX__AllocAccountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocAccount *) x));
}
static void *_p_FIX__MDImplicitDeleteTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::MDImplicitDelete *) x));
}
static void *_p_FIX__LegTimeUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegTimeUnit *) x));
}
static void *_p_FIX__TimeUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TimeUnit *) x));
}
static void *_p_FIX__DerivativeTimeUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeTimeUnit *) x));
}
static void *_p_FIX__UnderlyingTimeUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingTimeUnit *) x));
}
static void *_p_FIX__StandInstDbIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StandInstDbID *) x));
}
static void *_p_FIX__NotifyBrokerOfCreditTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::NotifyBrokerOfCredit *) x));
}
static void *_p_FIX__BrokerOfCreditTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BrokerOfCredit *) x));
}
static void *_p_FIX__UnderlyingSecuritySubTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecuritySubType *) x));
}
static void *_p_FIX__LegSecuritySubTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecuritySubType *) x));
}
static void *_p_FIX__DerivativeSecuritySubTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecuritySubType *) x));
}
static void *_p_FIX__SecuritySubTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySubType *) x));
}
static void *_p_FIX__UnderlyingLegSecuritySubTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecuritySubType *) x));
}
static void *_p_FIX__TrdSubTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdSubType *) x));
}
static void *_p_FIX__ShortSaleReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ShortSaleReason *) x));
}
static void *_p_FIX__DeleteReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DeleteReason *) x));
}
static void *_p_FIX__AllocCancReplaceReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocCancReplaceReason *) x));
}
static void *_p_FIX__DKReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DKReason *) x));
}
static void *_p_FIX__NetworkRequestIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NetworkRequestID *) x));
}
static void *_p_FIX__UserRequestIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UserRequestID *) x));
}
static void *_p_FIX__TradeRequestIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeRequestID *) x));
}
static void *_p_FIX__MarginExcessTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MarginExcess *) x));
}
static void *_p_FIX__RegistRejReasonTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistRejReasonText *) x));
}
static void *_p_FIX__ContraTradeTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ContraTradeTime *) x));
}
static void *_p_FIX__NoEventsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoEvents *) x));
}
static void *_p_FIX__NoDerivativeEventsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeEvents *) x));
}
static void *_p_FIX__BidPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidPx *) x));
}
static void *_p_FIX__UnderlyingLastQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingLastQty *) x));
}
static void *_p_FIX__CalculatedCcyLastQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CalculatedCcyLastQty *) x));
}
static void *_p_FIX__SideLastQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideLastQty *) x));
}
static void *_p_FIX__LegCalculatedCcyLastQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegCalculatedCcyLastQty *) x));
}
static void *_p_FIX__LegLastQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegLastQty *) x));
}
static void *_p_FIX__LastQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastQty *) x));
}
static void *_p_FIX__DeskIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeskID *) x));
}
static void *_p_FIX__CheckSumFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::CheckSumField *) x));
}
static void *_p_FIX__UsernameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Username *) x));
}
static void *_p_FIX__PosMaintRptIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosMaintRptID *) x));
}
static void *_p_FIX__ContIntRptIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContIntRptID *) x));
}
static void *_p_FIX__DerivativeStrikeValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeStrikeValue *) x));
}
static void *_p_FIX__StrikeValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikeValue *) x));
}
static void *_p_FIX__OptPayoutTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OptPayoutType *) x));
}
static void *_p_FIX__EncodedTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedText *) x));
}
static void *_p_FIX__GapFillFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::GapFillFlag *) x));
}
static void *_p_FIX__MarketDepthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MarketDepth *) x));
}
static void *_p_FIX__MDPriceLevelTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDPriceLevel *) x));
}
static void *_p_FIX__QuoteResponseLevelTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteResponseLevel *) x));
}
static void *_p_FIX__YieldCalcDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::YieldCalcDate *) x));
}
static void *_p_FIX__CollRptIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollRptID *) x));
}
static void *_p_FIX__LegNumberTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegNumber *) x));
}
static void *_p_FIX__PosTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosType *) x));
}
static void *_p_FIX__ContAmtTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContAmtType *) x));
}
static void *_p_FIX__PosAmtTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosAmtType *) x));
}
static void *_p_FIX__SettlInstIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstID *) x));
}
static void *_p_FIX__ReportedPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ReportedPx *) x));
}
static void *_p_FIX__LastFragmentTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LastFragment *) x));
}
static void *_p_FIX__PriceLimitTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PriceLimitType *) x));
}
static void *_p_FIX__PegLimitTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegLimitType *) x));
}
static void *_p_FIX__SecondaryPriceLimitTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecondaryPriceLimitType *) x));
}
static void *_p_FIX__DiscretionLimitTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionLimitType *) x));
}
static void *_p_FIX__NoLegStipulationsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLegStipulations *) x));
}
static void *_p_FIX__NoStipulationsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStipulations *) x));
}
static void *_p_FIX__ShortQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ShortQty *) x));
}
static void *_p_FIX__SellerDaysTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SellerDays *) x));
}
static void *_p_FIX__DiscretionOffsetTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionOffsetType *) x));
}
static void *_p_FIX__PegOffsetTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegOffsetType *) x));
}
static void *_p_FIX__TradSesEndTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesEndTime *) x));
}
static void *_p_FIX__ComplexEventEndTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::ComplexEventEndTime *) x));
}
static void *_p_FIX__TierCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TierCode *) x));
}
static void *_p_FIX__BenchmarkTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Benchmark *) x));
}
static void *_p_FIX__SpreadToBenchmarkTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SpreadToBenchmark *) x));
}
static void *_p_FIX__TransferReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TransferReason *) x));
}
static void *_p_FIX__CollAsgnRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnRejectReason *) x));
}
static void *_p_FIX__QuoteRequestRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRequestRejectReason *) x));
}
static void *_p_FIX__SessionRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SessionRejectReason *) x));
}
static void *_p_FIX__ListRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListRejectReason *) x));
}
static void *_p_FIX__CollAsgnReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnReason *) x));
}
static void *_p_FIX__QuoteRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRejectReason *) x));
}
static void *_p_FIX__TradeReportRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeReportRejectReason *) x));
}
static void *_p_FIX__StreamAsgnRejReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnRejReason *) x));
}
static void *_p_FIX__QuoteEntryRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteEntryRejectReason *) x));
}
static void *_p_FIX__ExecRestatementReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExecRestatementReason *) x));
}
static void *_p_FIX__OrdRejReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrdRejReason *) x));
}
static void *_p_FIX__MassCancelRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassCancelRejectReason *) x));
}
static void *_p_FIX__TradSesStatusRejReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesStatusRejReason *) x));
}
static void *_p_FIX__CxlRejReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CxlRejReason *) x));
}
static void *_p_FIX__ConfirmRejReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmRejReason *) x));
}
static void *_p_FIX__MassActionRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionRejectReason *) x));
}
static void *_p_FIX__RefOrdIDReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefOrdIDReason *) x));
}
static void *_p_FIX__MDReqRejReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MDReqRejReason *) x));
}
static void *_p_FIX__BusinessRejectReasonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BusinessRejectReason *) x));
}
static void *_p_FIX__AllocTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocText *) x));
}
static void *_p_FIX__EncodedAllocTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedAllocText *) x));
}
static void *_p_FIX__DeliverToSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliverToSubID *) x));
}
static void *_p_FIX__MiscFeeCurrTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MiscFeeCurr *) x));
}
static void *_p_FIX__SettlObligMsgIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlObligMsgID *) x));
}
static void *_p_FIX__ReportedPxDiffTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ReportedPxDiff *) x));
}
static void *_p_FIX__NoComplexEventsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoComplexEvents *) x));
}
static void *_p_FIX__NoNestedInstrAttribTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNestedInstrAttrib *) x));
}
static void *_p_FIX__NoInstrAttribTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoInstrAttrib *) x));
}
static void *_p_FIX__NoDerivativeInstrAttribTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeInstrAttrib *) x));
}
static void *_p_FIX__NoTrdRepIndicatorsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTrdRepIndicators *) x));
}
static void *_p_FIX__NoStatsIndicatorsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStatsIndicators *) x));
}
static void *_p_FIX__NoQuoteSetsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoQuoteSets *) x));
}
static void *_p_FIX__BeginSeqNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BeginSeqNo *) x));
}
static void *_p_FIX__EventPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EventPx *) x));
}
static void *_p_FIX__DerivativeEventPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeEventPx *) x));
}
static void *_p_FIX__StopPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StopPx *) x));
}
static void *_p_FIX__SecurityTradingEventTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityTradingEvent *) x));
}
static void *_p_FIX__CrossTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CrossType *) x));
}
static void *_p_FIX__EndStrikePxRangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndStrikePxRange *) x));
}
static void *_p_FIX__StartStrikePxRangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StartStrikePxRange *) x));
}
static void *_p_FIX__AgreementDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementDesc *) x));
}
static void *_p_FIX__MarketSegmentDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketSegmentDesc *) x));
}
static void *_p_FIX__OrderDelayTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrderDelay *) x));
}
static void *_p_FIX__OrderCategoryTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrderCategory *) x));
}
static void *_p_FIX__NewsCategoryTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NewsCategory *) x));
}
static void *_p_FIX__CardNumberTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardNumber *) x));
}
static void *_p_FIX__CashDistribAgentAcctNumberTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentAcctNumber *) x));
}
static void *_p_FIX__NoPositionsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPositions *) x));
}
static void *_p_FIX__NoUnderlyingsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyings *) x));
}
static void *_p_FIX__NoOfLegUnderlyingsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOfLegUnderlyings *) x));
}
static void *_p_FIX__NoDatesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDates *) x));
}
static void *_p_FIX__CardStartDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardStartDate *) x));
}
static void *_p_FIX__StartDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StartDate *) x));
}
static void *_p_FIX__ComplexEventStartDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ComplexEventStartDate *) x));
}
static void *_p_FIX__RefreshQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RefreshQty *) x));
}
static void *_p_FIX__OrigTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OrigTime *) x));
}
static void *_p_FIX__MDUpdateTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDUpdateType *) x));
}
static void *_p_FIX__MDQuoteTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDQuoteType *) x));
}
static void *_p_FIX__QuoteTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteType *) x));
}
static void *_p_FIX__NumBiddersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumBidders *) x));
}
static void *_p_FIX__AgreementDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementDate *) x));
}
static void *_p_FIX__EventDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EventDate *) x));
}
static void *_p_FIX__UnderlyingCouponPaymentDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCouponPaymentDate *) x));
}
static void *_p_FIX__PaymentDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PaymentDate *) x));
}
static void *_p_FIX__UnderlyingSettlementDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSettlementDate *) x));
}
static void *_p_FIX__CouponPaymentDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CouponPaymentDate *) x));
}
static void *_p_FIX__DerivativeEventDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEventDate *) x));
}
static void *_p_FIX__LegCouponPaymentDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCouponPaymentDate *) x));
}
static void *_p_FIX__UnderlyingSymbolSfxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSymbolSfx *) x));
}
static void *_p_FIX__DerivativeSymbolSfxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSymbolSfx *) x));
}
static void *_p_FIX__SymbolSfxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SymbolSfx *) x));
}
static void *_p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSymbolSfx *) x));
}
static void *_p_FIX__LegSymbolSfxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSymbolSfx *) x));
}
static void *_p_FIX__TrdTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdType *) x));
}
static void *_p_FIX__SecondaryTrdTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecondaryTrdType *) x));
}
static void *_p_FIX__RptSeqTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RptSeq *) x));
}
static void *_p_FIX__NoMsgTypesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMsgTypes *) x));
}
static void *_p_FIX__TriggerOrderTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerOrderType *) x));
}
static void *_p_FIX__StrategyParameterTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrategyParameterType *) x));
}
static void *_p_FIX__OwnerTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OwnerType *) x));
}
static void *_p_FIX__SettlSessSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlSessSubID *) x));
}
static void *_p_FIX__TickRuleTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TickRuleType *) x));
}
static void *_p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingFlowScheduleType *) x));
}
static void *_p_FIX__LegFlowScheduleTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegFlowScheduleType *) x));
}
static void *_p_FIX__DerivativeFlowScheduleTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeFlowScheduleType *) x));
}
static void *_p_FIX__FlowScheduleTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::FlowScheduleType *) x));
}
static void *_p_FIX__MiscFeeBasisTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MiscFeeBasis *) x));
}
static void *_p_FIX__EncodedTextLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedTextLen *) x));
}
static void *_p_FIX__EncodedAllocTextLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedAllocTextLen *) x));
}
static void *_p_FIX__TradSesEventTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesEvent *) x));
}
static void *_p_FIX__EncodedListStatusTextLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedListStatusTextLen *) x));
}
static void *_p_FIX__DisplayQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayQty *) x));
}
static void *_p_FIX__SecondaryDisplayQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryDisplayQty *) x));
}
static void *_p_FIX__TotNumTradeReportsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNumTradeReports *) x));
}
static void *_p_FIX__TotalNumPosReportsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalNumPosReports *) x));
}
static void *_p_FIX__TotNumReportsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNumReports *) x));
}
static void *_p_FIX__TotNumAssignmentReportsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNumAssignmentReports *) x));
}
static void *_p_FIX__SideSettlCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideSettlCurrency *) x));
}
static void *_p_FIX__LegBenchmarkCurveCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegBenchmarkCurveCurrency *) x));
}
static void *_p_FIX__BenchmarkCurveCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkCurveCurrency *) x));
}
static void *_p_FIX__LegAllocSettlCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocSettlCurrency *) x));
}
static void *_p_FIX__LegSettlCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSettlCurrency *) x));
}
static void *_p_FIX__TradingCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingCurrency *) x));
}
static void *_p_FIX__StrikeCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrikeCurrency *) x));
}
static void *_p_FIX__SettlCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlCurrency *) x));
}
static void *_p_FIX__CurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Currency *) x));
}
static void *_p_FIX__LegCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCurrency *) x));
}
static void *_p_FIX__SideCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideCurrency *) x));
}
static void *_p_FIX__AllocSettlCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocSettlCurrency *) x));
}
static void *_p_FIX__AgreementCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementCurrency *) x));
}
static void *_p_FIX__DerivativeStrikeCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeStrikeCurrency *) x));
}
static void *_p_FIX__UnderlyingStrikeCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStrikeCurrency *) x));
}
static void *_p_FIX__CommCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CommCurrency *) x));
}
static void *_p_FIX__UnderlyingCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCurrency *) x));
}
static void *_p_FIX__PositionCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PositionCurrency *) x));
}
static void *_p_FIX__LegStrikeCurrencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStrikeCurrency *) x));
}
static void *_p_FIX__TradeTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TradeType *) x));
}
static void *_p_FIX__BidTradeTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BidTradeType *) x));
}
static void *_p_FIX__SettleOnOpenFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettleOnOpenFlag *) x));
}
static void *_p_FIX__DerivativeSettleOnOpenFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSettleOnOpenFlag *) x));
}
static void *_p_FIX__LegLocaleOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegLocaleOfIssue *) x));
}
static void *_p_FIX__LocaleOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LocaleOfIssue *) x));
}
static void *_p_FIX__UnderlyingCountryOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCountryOfIssue *) x));
}
static void *_p_FIX__LegStateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__DerivativeCountryOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeCountryOfIssue *) x));
}
static void *_p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__DerivativeStateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__LegCountryOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCountryOfIssue *) x));
}
static void *_p_FIX__StateOrProvinceOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StateOrProvinceOfIssue *) x));
}
static void *_p_FIX__CountryOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CountryOfIssue *) x));
}
static void *_p_FIX__DerivativeLocaleOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeLocaleOfIssue *) x));
}
static void *_p_FIX__UnderlyingLocaleOfIssueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLocaleOfIssue *) x));
}
static void *_p_FIX__NoSettlInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlInst *) x));
}
static void *_p_FIX__NoTradingSessionsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTradingSessions *) x));
}
static void *_p_FIX__SeniorityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Seniority *) x));
}
static void *_p_FIX__UnderlyingSeniorityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSeniority *) x));
}
static void *_p_FIX__NoExecInstRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoExecInstRules *) x));
}
static void *_p_FIX__TimeBracketTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TimeBracket *) x));
}
static void *_p_FIX__PriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Price *) x));
}
static void *_p_FIX__SettlInstModeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlInstMode *) x));
}
static void *_p_FIX__ApplResponseErrorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplResponseError *) x));
}
static void *_p_FIX__HaltReasonIntTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::HaltReasonInt *) x));
}
static void *_p_FIX__ListNoOrdsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListNoOrds *) x));
}
static void *_p_FIX__LegSettlmntTypTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegSettlmntTyp *) x));
}
static void *_p_FIX__SettlmntTypTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlmntTyp *) x));
}
static void *_p_FIX__MinQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinQty *) x));
}
static void *_p_FIX__ScopeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Scope *) x));
}
static void *_p_FIX__AdvRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AdvRefID *) x));
}
static void *_p_FIX__BookingUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BookingUnit *) x));
}
static void *_p_FIX__LegLastPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegLastPx *) x));
}
static void *_p_FIX__UnderlyingLastPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingLastPx *) x));
}
static void *_p_FIX__PrevClosePxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PrevClosePx *) x));
}
static void *_p_FIX__MDReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDReportID *) x));
}
static void *_p_FIX__SecurityReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityReportID *) x));
}
static void *_p_FIX__SecondaryTradeReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryTradeReportID *) x));
}
static void *_p_FIX__ApplReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplReportID *) x));
}
static void *_p_FIX__MassActionReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MassActionReportID *) x));
}
static void *_p_FIX__MarketReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketReportID *) x));
}
static void *_p_FIX__LegReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegReportID *) x));
}
static void *_p_FIX__TradeReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeReportID *) x));
}
static void *_p_FIX__AllocReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocReportID *) x));
}
static void *_p_FIX__SideTradeReportIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideTradeReportID *) x));
}
static void *_p_FIX__CancellationRightsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CancellationRights *) x));
}
static void *_p_FIX__SecurityXMLTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityXML *) x));
}
static void *_p_FIX__DerivativeSecurityXMLTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityXML *) x));
}
static void *_p_FIX__NoMatchRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMatchRules *) x));
}
static void *_p_FIX__RawDataTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RawData *) x));
}
static void *_p_FIX__AllocHandlInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocHandlInst *) x));
}
static void *_p_FIX__HandlInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::HandlInst *) x));
}
static void *_p_FIX__OrdTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrdType *) x));
}
static void *_p_FIX__UnderlyingFactorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingFactor *) x));
}
static void *_p_FIX__LegFactorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegFactor *) x));
}
static void *_p_FIX__MatchTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MatchType *) x));
}
static void *_p_FIX__UnderlyingIssueDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingIssueDate *) x));
}
static void *_p_FIX__DerivativeIssueDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeIssueDate *) x));
}
static void *_p_FIX__IssueDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IssueDate *) x));
}
static void *_p_FIX__LegIssueDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIssueDate *) x));
}
static void *_p_FIX__TriggerTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerType *) x));
}
static void *_p_FIX__NoUnderlyingAmountsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingAmounts *) x));
}
static void *_p_FIX__SettlTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlType *) x));
}
static void *_p_FIX__LegSettlTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegSettlType *) x));
}
static void *_p_FIX__LiquidityIndTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LiquidityIndType *) x));
}
static void *_p_FIX__ConfirmTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmType *) x));
}
static void *_p_FIX__AllocAvgPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocAvgPx *) x));
}
static void *_p_FIX__SecurityReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityReqID *) x));
}
static void *_p_FIX__CollApplTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollApplType *) x));
}
static void *_p_FIX__CashMarginTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CashMargin *) x));
}
static void *_p_FIX__UnderlyingAllocationPercentTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingAllocationPercent *) x));
}
static void *_p_FIX__OrderPercentTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderPercent *) x));
}
static void *_p_FIX__CrossPercentTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CrossPercent *) x));
}
static void *_p_FIX__TradSesStartTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesStartTime *) x));
}
static void *_p_FIX__ComplexEventStartTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::ComplexEventStartTime *) x));
}
static void *_p_FIX__EncodedListExecInstLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedListExecInstLen *) x));
}
static void *_p_FIX__EventTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::EventTime *) x));
}
static void *_p_FIX__DerivativeEventTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::DerivativeEventTime *) x));
}
static void *_p_FIX__UndlyInstrumentPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UndlyInstrumentPartyRole *) x));
}
static void *_p_FIX__RootPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RootPartyRole *) x));
}
static void *_p_FIX__TrdRepPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdRepPartyRole *) x));
}
static void *_p_FIX__InstrumentPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::InstrumentPartyRole *) x));
}
static void *_p_FIX__Nested4PartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested4PartyRole *) x));
}
static void *_p_FIX__NestedPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NestedPartyRole *) x));
}
static void *_p_FIX__Nested3PartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested3PartyRole *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeInstrumentPartyRole *) x));
}
static void *_p_FIX__PartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartyRole *) x));
}
static void *_p_FIX__SettlPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlPartyRole *) x));
}
static void *_p_FIX__Nested2PartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested2PartyRole *) x));
}
static void *_p_FIX__TargetPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TargetPartyRole *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyRoleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingInstrumentPartyRole *) x));
}
static void *_p_FIX__CashSettlAgentCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentCode *) x));
}
static void *_p_FIX__SecuritySettlAgentCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentCode *) x));
}
static void *_p_FIX__CashDistribAgentCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentCode *) x));
}
static void *_p_FIX__LegCreditRatingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegCreditRating *) x));
}
static void *_p_FIX__CreditRatingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CreditRating *) x));
}
static void *_p_FIX__UnderlyingCreditRatingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCreditRating *) x));
}
static void *_p_FIX__CxlQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CxlQty *) x));
}
static void *_p_FIX__UnderlyingCashTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCashType *) x));
}
static void *_p_FIX__ConfirmReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ConfirmReqID *) x));
}
static void *_p_FIX__NoBidDescriptorsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoBidDescriptors *) x));
}
static void *_p_FIX__LegDividendYieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegDividendYield *) x));
}
static void *_p_FIX__DividendYieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DividendYield *) x));
}
static void *_p_FIX__NetworkResponseIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NetworkResponseID *) x));
}
static void *_p_FIX__SecurityResponseIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityResponseID *) x));
}
static void *_p_FIX__LastNetworkResponseIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LastNetworkResponseID *) x));
}
static void *_p_FIX__ApplResponseIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplResponseID *) x));
}
static void *_p_FIX__MultilegModelTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MultilegModel *) x));
}
static void *_p_FIX__ContraTradeQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ContraTradeQty *) x));
}
static void *_p_FIX__InViewOfCommonTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::InViewOfCommon *) x));
}
static void *_p_FIX__CrossPrioritizationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CrossPrioritization *) x));
}
static void *_p_FIX__LastPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastPx *) x));
}
static void *_p_FIX__DisplayLowQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayLowQty *) x));
}
static void *_p_FIX__RateSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RateSource *) x));
}
static void *_p_FIX__SecurityListTypeSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityListTypeSource *) x));
}
static void *_p_FIX__SettlObligSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlObligSource *) x));
}
static void *_p_FIX__LegCoveredOrUncoveredTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegCoveredOrUncovered *) x));
}
static void *_p_FIX__CoveredOrUncoveredTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CoveredOrUncovered *) x));
}
static void *_p_FIX__QuoteReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteReqID *) x));
}
static void *_p_FIX__DeskTypeSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DeskTypeSource *) x));
}
static void *_p_FIX__DerivativeFloorPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeFloorPrice *) x));
}
static void *_p_FIX__TriggerPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TriggerPrice *) x));
}
static void *_p_FIX__FloorPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FloorPrice *) x));
}
static void *_p_FIX__PutOrCallTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PutOrCall *) x));
}
static void *_p_FIX__LegPutOrCallTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegPutOrCall *) x));
}
static void *_p_FIX__DerivativePutOrCallTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativePutOrCall *) x));
}
static void *_p_FIX__UnderlyingLegPutOrCallTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingLegPutOrCall *) x));
}
static void *_p_FIX__UnderlyingPutOrCallTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingPutOrCall *) x));
}
static void *_p_FIX__NoLegsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLegs *) x));
}
static void *_p_FIX__CashSettlAgentAcctNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentAcctNum *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentAcctNum *) x));
}
static void *_p_FIX__StandInstDbNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StandInstDbName *) x));
}
static void *_p_FIX__RiskFreeRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RiskFreeRate *) x));
}
static void *_p_FIX__QuoteRespIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteRespID *) x));
}
static void *_p_FIX__YieldRedemptionPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::YieldRedemptionPrice *) x));
}
static void *_p_FIX__DiscretionPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DiscretionPrice *) x));
}
static void *_p_FIX__CxlTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CxlType *) x));
}
static void *_p_FIX__CPRegTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CPRegType *) x));
}
static void *_p_FIX__CollAsgnRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollAsgnRefID *) x));
}
static void *_p_FIX__FactorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Factor *) x));
}
static void *_p_FIX__NoExpirationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoExpiration *) x));
}
static void *_p_FIX__TimeToExpirationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TimeToExpiration *) x));
}
static void *_p_FIX__UnderlyingCPRegTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCPRegType *) x));
}
static void *_p_FIX__OwnershipTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OwnershipType *) x));
}
static void *_p_FIX__UnderlyingStipTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStipType *) x));
}
static void *_p_FIX__PriceProtectionScopeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PriceProtectionScope *) x));
}
static void *_p_FIX__MassActionScopeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionScope *) x));
}
static void *_p_FIX__DiscretionScopeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionScope *) x));
}
static void *_p_FIX__ResponseDestinationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ResponseDestination *) x));
}
static void *_p_FIX__ExDestinationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExDestination *) x));
}
static void *_p_FIX__DesignationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Designation *) x));
}
static void *_p_FIX__TradSesOpenTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesOpenTime *) x));
}
static void *_p_FIX__NoUnderlyingStipsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingStips *) x));
}
static void *_p_FIX__PeggedRefPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PeggedRefPrice *) x));
}
static void *_p_FIX__LegOptionRatioTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOptionRatio *) x));
}
static void *_p_FIX__MarginRatioTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MarginRatio *) x));
}
static void *_p_FIX__UrgencyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Urgency *) x));
}
static void *_p_FIX__LowPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LowPx *) x));
}
static void *_p_FIX__PaymentRefTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PaymentRef *) x));
}
static void *_p_FIX__ExchangeForPhysicalTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ExchangeForPhysical *) x));
}
static void *_p_FIX__DefOfferSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DefOfferSize *) x));
}
static void *_p_FIX__OfferSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferSize *) x));
}
static void *_p_FIX__MinOfferSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinOfferSize *) x));
}
static void *_p_FIX__EncodedMktSegmDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedMktSegmDesc *) x));
}
static void *_p_FIX__RFQReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RFQReqID *) x));
}
static void *_p_FIX__SideQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideQty *) x));
}
static void *_p_FIX__AllocSettlCurrAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocSettlCurrAmt *) x));
}
static void *_p_FIX__SettlCurrAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrAmt *) x));
}
static void *_p_FIX__XmlDataTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::XmlData *) x));
}
static void *_p_FIX__NumTicketsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumTickets *) x));
}
static void *_p_FIX__NoRptsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRpts *) x));
}
static void *_p_FIX__IOINaturalFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::IOINaturalFlag *) x));
}
static void *_p_FIX__ComplexEventConditionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventCondition *) x));
}
static void *_p_FIX__TradeConditionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeCondition *) x));
}
static void *_p_FIX__QuoteConditionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteCondition *) x));
}
static void *_p_FIX__BidYieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidYield *) x));
}
static void *_p_FIX__MidYieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MidYield *) x));
}
static void *_p_FIX__NetGrossIndTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NetGrossInd *) x));
}
static void *_p_FIX__ExecValuationPointTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ExecValuationPoint *) x));
}
static void *_p_FIX__AffectedOrderIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AffectedOrderID *) x));
}
static void *_p_FIX__OrderIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrderID *) x));
}
static void *_p_FIX__NotAffectedOrderIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NotAffectedOrderID *) x));
}
static void *_p_FIX__AffectedSecondaryOrderIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AffectedSecondaryOrderID *) x));
}
static void *_p_FIX__SecondaryOrderIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryOrderID *) x));
}
static void *_p_FIX__RefOrderIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefOrderID *) x));
}
static void *_p_FIX__ReferencePageTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ReferencePage *) x));
}
static void *_p_FIX__SettlPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlPartyIDSource *) x));
}
static void *_p_FIX__AllocAcctIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocAcctIDSource *) x));
}
static void *_p_FIX__UnderlyingSecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityIDSource *) x));
}
static void *_p_FIX__PartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PartyIDSource *) x));
}
static void *_p_FIX__InputSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InputSource *) x));
}
static void *_p_FIX__PegSecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSecurityIDSource *) x));
}
static void *_p_FIX__TriggerSecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSecurityIDSource *) x));
}
static void *_p_FIX__LegSecurityAltIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityAltIDSource *) x));
}
static void *_p_FIX__NestedPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::NestedPartyIDSource *) x));
}
static void *_p_FIX__UnderlyingIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingIDSource *) x));
}
static void *_p_FIX__SecurityAltIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityAltIDSource *) x));
}
static void *_p_FIX__SecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityIDSource *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrumentPartyIDSource *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingInstrumentPartyIDSource *) x));
}
static void *_p_FIX__NoAltMDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAltMDSource *) x));
}
static void *_p_FIX__ExDestinationIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExDestinationIDSource *) x));
}
static void *_p_FIX__OrderHandlingInstSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrderHandlingInstSource *) x));
}
static void *_p_FIX__BenchmarkSecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkSecurityIDSource *) x));
}
static void *_p_FIX__DerivativeSecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityIDSource *) x));
}
static void *_p_FIX__AcctIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AcctIDSource *) x));
}
static void *_p_FIX__Nested4PartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Nested4PartyIDSource *) x));
}
static void *_p_FIX__RootPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RootPartyIDSource *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityAltIDSource *) x));
}
static void *_p_FIX__Nested3PartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Nested3PartyIDSource *) x));
}
static void *_p_FIX__IDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IDSource *) x));
}
static void *_p_FIX__TargetPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TargetPartyIDSource *) x));
}
static void *_p_FIX__InstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::InstrumentPartyIDSource *) x));
}
static void *_p_FIX__LegSecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityIDSource *) x));
}
static void *_p_FIX__SettlInstSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlInstSource *) x));
}
static void *_p_FIX__TradeInputSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeInputSource *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UndlyInstrumentPartyIDSource *) x));
}
static void *_p_FIX__MessageEventSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MessageEventSource *) x));
}
static void *_p_FIX__ApplTotalMessageCountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplTotalMessageCount *) x));
}
static void *_p_FIX__RefOrderIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RefOrderIDSource *) x));
}
static void *_p_FIX__Nested2PartyIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Nested2PartyIDSource *) x));
}
static void *_p_FIX__LegAllocAcctIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocAcctIDSource *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDSourceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityIDSource *) x));
}
static void *_p_FIX__FairValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FairValue *) x));
}
static void *_p_FIX__StrategyParameterValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrategyParameterValue *) x));
}
static void *_p_FIX__LegalConfirmTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LegalConfirm *) x));
}
static void *_p_FIX__ContractSettlMonthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContractSettlMonth *) x));
}
static void *_p_FIX__LegContractSettlMonthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegContractSettlMonth *) x));
}
static void *_p_FIX__QuoteIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteID *) x));
}
static void *_p_FIX__DerivativeContractSettlMonthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeContractSettlMonth *) x));
}
static void *_p_FIX__TransBkdTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TransBkdTime *) x));
}
static void *_p_FIX__CollRespIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollRespID *) x));
}
static void *_p_FIX__SideTrdRegTimestampTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideTrdRegTimestampType *) x));
}
static void *_p_FIX__TrdRegTimestampTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdRegTimestampType *) x));
}
static void *_p_FIX__LegStipulationValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStipulationValue *) x));
}
static void *_p_FIX__StipulationValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StipulationValue *) x));
}
static void *_p_FIX__CharFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::CharField *) x));
}
static void *_p_FIX__TradSesModeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesMode *) x));
}
static void *_p_FIX__CountryTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Country *) x));
}
static void *_p_FIX__MDEntryDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcDateField *) ((FIX::MDEntryDate *) x));
}
static void *_p_FIX__Rule80ATo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Rule80A *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartiesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeInstrumentParties *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUndlyInstrumentParties *) x));
}
static void *_p_FIX__NoInstrumentPartiesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoInstrumentParties *) x));
}
static void *_p_FIX__LongQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LongQty *) x));
}
static void *_p_FIX__LegSwapTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegSwapType *) x));
}
static void *_p_FIX__FillQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FillQty *) x));
}
static void *_p_FIX__InstrAttribValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrAttribValue *) x));
}
static void *_p_FIX__DerivativeInstrAttribValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrAttribValue *) x));
}
static void *_p_FIX__NestedInstrAttribValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NestedInstrAttribValue *) x));
}
static void *_p_FIX__RoundingModulusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RoundingModulus *) x));
}
static void *_p_FIX__AllocLinkTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocLinkType *) x));
}
static void *_p_FIX__AllocReportTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocReportType *) x));
}
static void *_p_FIX__TradeReportTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeReportType *) x));
}
static void *_p_FIX__ResponseTransportTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ResponseTransportType *) x));
}
static void *_p_FIX__EncryptedPasswordTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncryptedPassword *) x));
}
static void *_p_FIX__PasswordTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Password *) x));
}
static void *_p_FIX__EncryptedNewPasswordTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncryptedNewPassword *) x));
}
static void *_p_FIX__NewPasswordTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NewPassword *) x));
}
static void *_p_FIX__ApplReportTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplReportType *) x));
}
static void *_p_FIX__UnderlyingSettlementTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingSettlementType *) x));
}
static void *_p_FIX__EventTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EventType *) x));
}
static void *_p_FIX__ComplexEventTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventType *) x));
}
static void *_p_FIX__AllocAccountTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocAccountType *) x));
}
static void *_p_FIX__AccountTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AccountType *) x));
}
static void *_p_FIX__AdjustmentTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AdjustmentType *) x));
}
static void *_p_FIX__DerivativeEventTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeEventType *) x));
}
static void *_p_FIX__RespondentTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RespondentType *) x));
}
static void *_p_FIX__FutSettDate2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FutSettDate2 *) x));
}
static void *_p_FIX__PriceDeltaTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriceDelta *) x));
}
static void *_p_FIX__SideValue1To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SideValue1 *) x));
}
static void *_p_FIX__SideValue2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SideValue2 *) x));
}
static void *_p_FIX__DerivativeSymbolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSymbol *) x));
}
static void *_p_FIX__LegSymbolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSymbol *) x));
}
static void *_p_FIX__UnderlyingSymbolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSymbol *) x));
}
static void *_p_FIX__UnderlyingLegSymbolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSymbol *) x));
}
static void *_p_FIX__PegSymbolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSymbol *) x));
}
static void *_p_FIX__OrderQty2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderQty2 *) x));
}
static void *_p_FIX__AltMDSourceIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AltMDSourceID *) x));
}
static void *_p_FIX__TotNoQuoteEntriesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoQuoteEntries *) x));
}
static void *_p_FIX__NoMDEntriesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMDEntries *) x));
}
static void *_p_FIX__TotQuoteEntriesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotQuoteEntries *) x));
}
static void *_p_FIX__NoQuoteEntriesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoQuoteEntries *) x));
}
static void *_p_FIX__VenueTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::VenueType *) x));
}
static void *_p_FIX__TriggerNewQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TriggerNewQty *) x));
}
static void *_p_FIX__SideTimeInForceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::SideTimeInForce *) x));
}
static void *_p_FIX__TimeInForceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TimeInForce *) x));
}
static void *_p_FIX__SettlInstMsgIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstMsgID *) x));
}
static void *_p_FIX__AdvSideTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AdvSide *) x));
}
static void *_p_FIX__SettlDate2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlDate2 *) x));
}
static void *_p_FIX__OrigOrdModTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OrigOrdModTime *) x));
}
static void *_p_FIX__ApplQueueDepthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueDepth *) x));
}
static void *_p_FIX__MatchAlgorithmTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MatchAlgorithm *) x));
}
static void *_p_FIX__SignatureTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Signature *) x));
}
static void *_p_FIX__InterestAccrualDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InterestAccrualDate *) x));
}
static void *_p_FIX__LegInterestAccrualDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegInterestAccrualDate *) x));
}
static void *_p_FIX__SendingDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SendingDate *) x));
}
static void *_p_FIX__RegistIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistID *) x));
}
static void *_p_FIX__NewSeqNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NewSeqNo *) x));
}
static void *_p_FIX__LegInstrRegistryTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegInstrRegistry *) x));
}
static void *_p_FIX__InstrRegistryTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrRegistry *) x));
}
static void *_p_FIX__NoMaturityRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMaturityRules *) x));
}
static void *_p_FIX__DerivativeInstrRegistryTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrRegistry *) x));
}
static void *_p_FIX__UnderlyingInstrRegistryTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingInstrRegistry *) x));
}
static void *_p_FIX__MiscFeeTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MiscFeeType *) x));
}
static void *_p_FIX__DeliveryDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliveryDate *) x));
}
static void *_p_FIX__ValidUntilTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ValidUntilTime *) x));
}
static void *_p_FIX__QuoteSetValidUntilTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::QuoteSetValidUntilTime *) x));
}
static void *_p_FIX__ClientBidIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClientBidID *) x));
}
static void *_p_FIX__EncodedSecurityListDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedSecurityListDesc *) x));
}
static void *_p_FIX__SecurityListDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityListDesc *) x));
}
static void *_p_FIX__ParentMktSegmIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ParentMktSegmID *) x));
}
static void *_p_FIX__StatsTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StatsType *) x));
}
static void *_p_FIX__NoComplexEventDatesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoComplexEventDates *) x));
}
static void *_p_FIX__LiquidityPctHighTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LiquidityPctHigh *) x));
}
static void *_p_FIX__SideReasonCdTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideReasonCd *) x));
}
static void *_p_FIX__SymbolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Symbol *) x));
}
static void *_p_FIX__TriggerSymbolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSymbol *) x));
}
static void *_p_FIX__NoSidesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSides *) x));
}
static void *_p_FIX__MDEntryTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::MDEntryTime *) x));
}
static void *_p_FIX__ReportToExchTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ReportToExch *) x));
}
static void *_p_FIX__EncodedSubjectTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedSubject *) x));
}
static void *_p_FIX__SubjectTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Subject *) x));
}
static void *_p_FIX__AllocLinkIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocLinkID *) x));
}
static void *_p_FIX__TradeLinkIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeLinkID *) x));
}
static void *_p_FIX__LegBidPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegBidPx *) x));
}
static void *_p_FIX__NoLotTypeRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLotTypeRules *) x));
}
static void *_p_FIX__ApplQueueMaxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueMax *) x));
}
static void *_p_FIX__NoOrdTypeRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOrdTypeRules *) x));
}
static void *_p_FIX__FundRenewWaivTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::FundRenewWaiv *) x));
}
static void *_p_FIX__AdjustmentTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Adjustment *) x));
}
static void *_p_FIX__ExecPriceAdjustmentTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ExecPriceAdjustment *) x));
}
static void *_p_FIX__TargetSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetSubID *) x));
}
static void *_p_FIX__ComplexEventPriceTimeTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventPriceTimeType *) x));
}
static void *_p_FIX__LegOfferPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOfferPx *) x));
}
static void *_p_FIX__MktOfferPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MktOfferPx *) x));
}
static void *_p_FIX__OfferPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferPx *) x));
}
static void *_p_FIX__LegPoolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegPool *) x));
}
static void *_p_FIX__NoMDFeedTypesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMDFeedTypes *) x));
}
static void *_p_FIX__LastSpotRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastSpotRate *) x));
}
static void *_p_FIX__OfferSpotRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferSpotRate *) x));
}
static void *_p_FIX__BidSpotRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidSpotRate *) x));
}
static void *_p_FIX__MDEntrySpotRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntrySpotRate *) x));
}
static void *_p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityXMLSchema *) x));
}
static void *_p_FIX__SecurityXMLSchemaTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityXMLSchema *) x));
}
static void *_p_FIX__SettlInstCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstCode *) x));
}
static void *_p_FIX__OpenInterestTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OpenInterest *) x));
}
static void *_p_FIX__NumDaysInterestTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumDaysInterest *) x));
}
static void *_p_FIX__SideValueIndTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideValueInd *) x));
}
static void *_p_FIX__UnderlyingLegMaturityMonthYearTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegMaturityMonthYear *) x));
}
static void *_p_FIX__EndMaturityMonthYearTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EndMaturityMonthYear *) x));
}
static void *_p_FIX__UnderlyingMaturityMonthYearTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityMonthYear *) x));
}
static void *_p_FIX__DerivativeMaturityMonthYearTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeMaturityMonthYear *) x));
}
static void *_p_FIX__MaturityMonthYearTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityMonthYear *) x));
}
static void *_p_FIX__StartMaturityMonthYearTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StartMaturityMonthYear *) x));
}
static void *_p_FIX__LegMaturityMonthYearTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegMaturityMonthYear *) x));
}
static void *_p_FIX__NoQuoteQualifiersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoQuoteQualifiers *) x));
}
static void *_p_FIX__NoIOIQualifiersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoIOIQualifiers *) x));
}
static void *_p_FIX__MDOriginTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDOriginType *) x));
}
static void *_p_FIX__DayOrderQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DayOrderQty *) x));
}
static void *_p_FIX__CashOrderQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CashOrderQty *) x));
}
static void *_p_FIX__LegOrderQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOrderQty *) x));
}
static void *_p_FIX__OrderQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderQty *) x));
}
static void *_p_FIX__OrderInputDeviceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrderInputDevice *) x));
}
static void *_p_FIX__TradeInputDeviceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeInputDevice *) x));
}
static void *_p_FIX__RoutingIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RoutingID *) x));
}
static void *_p_FIX__NoSettlObligTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlOblig *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityAltID *) x));
}
static void *_p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeSecurityAltID *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__NoSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSecurityAltID *) x));
}
static void *_p_FIX__SecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityAltID *) x));
}
static void *_p_FIX__NoLegSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLegSecurityAltID *) x));
}
static void *_p_FIX__LegSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingSecurityAltID *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__HopSendingTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::HopSendingTime *) x));
}
static void *_p_FIX__OrigSendingTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OrigSendingTime *) x));
}
static void *_p_FIX__OnBehalfOfSendingTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::OnBehalfOfSendingTime *) x));
}
static void *_p_FIX__SendingTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::SendingTime *) x));
}
static void *_p_FIX__ExecInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecInst *) x));
}
static void *_p_FIX__EncodedListExecInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedListExecInst *) x));
}
static void *_p_FIX__LegExecInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegExecInst *) x));
}
static void *_p_FIX__ListExecInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListExecInst *) x));
}
static void *_p_FIX__NoLinesOfTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLinesOfText *) x));
}
static void *_p_FIX__LinesOfTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LinesOfText *) x));
}
static void *_p_FIX__SettlDepositoryCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlDepositoryCode *) x));
}
static void *_p_FIX__TradedFlatSwitchTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::TradedFlatSwitch *) x));
}
static void *_p_FIX__ClOrdLinkIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClOrdLinkID *) x));
}
static void *_p_FIX__NoStrikeRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStrikeRules *) x));
}
static void *_p_FIX__NoTimeInForceRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTimeInForceRules *) x));
}
static void *_p_FIX__IOIidTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIid *) x));
}
static void *_p_FIX__LegBenchmarkPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegBenchmarkPrice *) x));
}
static void *_p_FIX__BenchmarkPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BenchmarkPrice *) x));
}
static void *_p_FIX__DueToRelatedTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::DueToRelated *) x));
}
static void *_p_FIX__DlvyInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DlvyInst *) x));
}
static void *_p_FIX__NoDlvyInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDlvyInst *) x));
}
static void *_p_FIX__SecureDataTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecureData *) x));
}
static void *_p_FIX__AccruedInterestRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AccruedInterestRate *) x));
}
static void *_p_FIX__MDMktTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDMkt *) x));
}
static void *_p_FIX__MessageEncodingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MessageEncoding *) x));
}
static void *_p_FIX__BasisFeatureDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BasisFeatureDate *) x));
}
static void *_p_FIX__ExpireDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExpireDate *) x));
}
static void *_p_FIX__DisplayWhenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DisplayWhen *) x));
}
static void *_p_FIX__EndTickPriceRangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndTickPriceRange *) x));
}
static void *_p_FIX__StartTickPriceRangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StartTickPriceRange *) x));
}
static void *_p_FIX__NoCompIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoCompIDs *) x));
}
static void *_p_FIX__BookingRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BookingRefID *) x));
}
static void *_p_FIX__WtAverageLiquidityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::WtAverageLiquidity *) x));
}
static void *_p_FIX__PriceImprovementTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriceImprovement *) x));
}
static void *_p_FIX__SideTrdSubTypTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideTrdSubTyp *) x));
}
static void *_p_FIX__MinPriceIncrementTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinPriceIncrement *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeMinPriceIncrement *) x));
}
static void *_p_FIX__StrikeIncrementTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikeIncrement *) x));
}
static void *_p_FIX__MatchIncrementTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MatchIncrement *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaturityMonthYearIncrement *) x));
}
static void *_p_FIX__TickIncrementTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TickIncrement *) x));
}
static void *_p_FIX__ExecTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecType *) x));
}
static void *_p_FIX__MailingDtlsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MailingDtls *) x));
}
static void *_p_FIX__HaltReasonCharTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::HaltReasonChar *) x));
}
static void *_p_FIX__ModelTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ModelType *) x));
}
static void *_p_FIX__EventTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EventText *) x));
}
static void *_p_FIX__DerivativeEventTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEventText *) x));
}
static void *_p_FIX__SettlInstReqRejCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlInstReqRejCode *) x));
}
static void *_p_FIX__TriggerNewPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TriggerNewPrice *) x));
}
static void *_p_FIX__AllocRejCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocRejCode *) x));
}
static void *_p_FIX__IndividualAllocRejCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::IndividualAllocRejCode *) x));
}
static void *_p_FIX__ClearingFirmTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingFirm *) x));
}
static void *_p_FIX__SettlementCycleNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlementCycleNo *) x));
}
static void *_p_FIX__TransactTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TransactTime *) x));
}
static void *_p_FIX__TZTransactTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TZTransactTime *) x));
}
static void *_p_FIX__RelSymTransactTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::RelSymTransactTime *) x));
}
static void *_p_FIX__PriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativePriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnitOfMeasureQty *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegUnitOfMeasureQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegUnitOfMeasureQty *) x));
}
static void *_p_FIX__NewsRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NewsRefID *) x));
}
static void *_p_FIX__MDEntryTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MDEntryType *) x));
}
static void *_p_FIX__AvgParPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AvgParPx *) x));
}
static void *_p_FIX__IOIQltyIndTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOIQltyInd *) x));
}
static void *_p_FIX__NoAllocsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAllocs *) x));
}
static void *_p_FIX__TotNoAllocsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoAllocs *) x));
}
static void *_p_FIX__NoLegAllocsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoLegAllocs *) x));
}
static void *_p_FIX__RegistDtlsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistDtls *) x));
}
static void *_p_FIX__NoRegistDtlsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRegistDtls *) x));
}
static void *_p_FIX__DeskOrderHandlingInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeskOrderHandlingInst *) x));
}
static void *_p_FIX__GTBookingInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::GTBookingInst *) x));
}
static void *_p_FIX__CustOrderHandlingInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CustOrderHandlingInst *) x));
}
static void *_p_FIX__MailingInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MailingInst *) x));
}
static void *_p_FIX__DayBookingInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DayBookingInst *) x));
}
static void *_p_FIX__LegPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegPrice *) x));
}
static void *_p_FIX__RefApplVerIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefApplVerID *) x));
}
static void *_p_FIX__CstmApplVerIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CstmApplVerID *) x));
}
static void *_p_FIX__DefaultApplVerIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DefaultApplVerID *) x));
}
static void *_p_FIX__RefCstmApplVerIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefCstmApplVerID *) x));
}
static void *_p_FIX__ApplVerIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplVerID *) x));
}
static void *_p_FIX__DefaultCstmApplVerIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DefaultCstmApplVerID *) x));
}
static void *_p_FIX__LastMsgSeqNumProcessedTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LastMsgSeqNumProcessed *) x));
}
static void *_p_FIX__DateOfBirthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DateOfBirth *) x));
}
static void *_p_FIX__SettlObligRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlObligRefID *) x));
}
static void *_p_FIX__LegRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegRefID *) x));
}
static void *_p_FIX__ContraLegRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContraLegRefID *) x));
}
static void *_p_FIX__TradeLegRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeLegRefID *) x));
}
static void *_p_FIX__NoRateSourcesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRateSources *) x));
}
static void *_p_FIX__NotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::NotionalPercentageOutstanding *) x));
}
static void *_p_FIX__CashOutstandingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CashOutstanding *) x));
}
static void *_p_FIX__UnderlyingNotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__TrdMatchIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TrdMatchID *) x));
}
static void *_p_FIX__OriginalNotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__DeliverToCompIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliverToCompID *) x));
}
static void *_p_FIX__AllocPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocPrice *) x));
}
static void *_p_FIX__StringFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::StringField *) x));
}
static void *_p_FIX__DlvyInstTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DlvyInstType *) x));
}
static void *_p_FIX__ListExecInstTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ListExecInstType *) x));
}
static void *_p_FIX__AllocSettlInstTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocSettlInstType *) x));
}
static void *_p_FIX__TriggerTradingSessionIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerTradingSessionID *) x));
}
static void *_p_FIX__TradingSessionIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingSessionID *) x));
}
static void *_p_FIX__UnderlyingTradingSessionIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingTradingSessionID *) x));
}
static void *_p_FIX__PegScopeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegScope *) x));
}
static void *_p_FIX__TotNoAccQuotesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoAccQuotes *) x));
}
static void *_p_FIX__CollInquiryIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollInquiryID *) x));
}
static void *_p_FIX__ExecRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecRefID *) x));
}
static void *_p_FIX__CxlRejResponseToTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CxlRejResponseTo *) x));
}
static void *_p_FIX__LotTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LotType *) x));
}
static void *_p_FIX__SideTrdRegTimestampSrcTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideTrdRegTimestampSrc *) x));
}
static void *_p_FIX__EmailTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::EmailType *) x));
}
static void *_p_FIX__DerivativeOptAttributeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeOptAttribute *) x));
}
static void *_p_FIX__UnderlyingLegOptAttributeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingLegOptAttribute *) x));
}
static void *_p_FIX__UnderlyingOptAttributeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingOptAttribute *) x));
}
static void *_p_FIX__OptAttributeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OptAttribute *) x));
}
static void *_p_FIX__LegOptAttributeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegOptAttribute *) x));
}
static void *_p_FIX__SettlLocationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlLocation *) x));
}
static void *_p_FIX__EffectiveTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::EffectiveTime *) x));
}
static void *_p_FIX__StreamAsgnReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StreamAsgnReqID *) x));
}
static void *_p_FIX__QuoteCancelTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteCancelType *) x));
}
static void *_p_FIX__ExpireTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ExpireTime *) x));
}
static void *_p_FIX__SettlBrkrCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlBrkrCode *) x));
}
static void *_p_FIX__PreTradeAnonymityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PreTradeAnonymity *) x));
}
static void *_p_FIX__RestructuringTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RestructuringType *) x));
}
static void *_p_FIX__RoutingTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RoutingType *) x));
}
static void *_p_FIX__MultiLegReportingTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MultiLegReportingType *) x));
}
static void *_p_FIX__SideMultiLegReportingTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideMultiLegReportingType *) x));
}
static void *_p_FIX__UnderlyingRestructuringTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingRestructuringType *) x));
}
static void *_p_FIX__BookingTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BookingType *) x));
}
static void *_p_FIX__StatusValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StatusValue *) x));
}
static void *_p_FIX__AllowableOneSidednessValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllowableOneSidednessValue *) x));
}
static void *_p_FIX__NoTrdRegTimestampsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTrdRegTimestamps *) x));
}
static void *_p_FIX__SecurityListIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityListID *) x));
}
static void *_p_FIX__DeliveryTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DeliveryType *) x));
}
static void *_p_FIX__SettlDeliveryTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlDeliveryType *) x));
}
static void *_p_FIX__PrivateQuoteTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PrivateQuote *) x));
}
static void *_p_FIX__EncodedHeadlineLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedHeadlineLen *) x));
}
static void *_p_FIX__BasisPxTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BasisPxType *) x));
}
static void *_p_FIX__StrikeRuleIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrikeRuleID *) x));
}
static void *_p_FIX__MaturityRuleIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityRuleID *) x));
}
static void *_p_FIX__QuoteMsgIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteMsgID *) x));
}
static void *_p_FIX__DeskTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeskType *) x));
}
static void *_p_FIX__CardHolderNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardHolderName *) x));
}
static void *_p_FIX__StrategyParameterNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StrategyParameterName *) x));
}
static void *_p_FIX__RndPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RndPx *) x));
}
static void *_p_FIX__TotNoSecurityTypesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoSecurityTypes *) x));
}
static void *_p_FIX__NoMDEntryTypesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMDEntryTypes *) x));
}
static void *_p_FIX__TotalNumSecurityTypesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalNumSecurityTypes *) x));
}
static void *_p_FIX__MaxPriceLevelsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaxPriceLevels *) x));
}
static void *_p_FIX__NoSecurityTypesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSecurityTypes *) x));
}
static void *_p_FIX__OnBehalfOfCompIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OnBehalfOfCompID *) x));
}
static void *_p_FIX__HopCompIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::HopCompID *) x));
}
static void *_p_FIX__TargetCompIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetCompID *) x));
}
static void *_p_FIX__SenderCompIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SenderCompID *) x));
}
static void *_p_FIX__RefCompIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefCompID *) x));
}
static void *_p_FIX__ListStatusTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListStatusType *) x));
}
static void *_p_FIX__MDBookTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDBookType *) x));
}
static void *_p_FIX__MDSubBookTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDSubBookType *) x));
}
static void *_p_FIX__MassCancelRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MassCancelRequestType *) x));
}
static void *_p_FIX__SecurityRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityRequestType *) x));
}
static void *_p_FIX__SecurityListRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityListRequestType *) x));
}
static void *_p_FIX__QuoteRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRequestType *) x));
}
static void *_p_FIX__SecurityListTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityListType *) x));
}
static void *_p_FIX__TradeRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeRequestType *) x));
}
static void *_p_FIX__UserRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UserRequestType *) x));
}
static void *_p_FIX__NetworkRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NetworkRequestType *) x));
}
static void *_p_FIX__SubscriptionRequestTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SubscriptionRequestType *) x));
}
static void *_p_FIX__EncodedIssuerLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedIssuerLen *) x));
}
static void *_p_FIX__EncodedLegIssuerLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedLegIssuerLen *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeEncodedIssuerLen *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedUnderlyingIssuerLen *) x));
}
static void *_p_FIX__TotNoRejQuotesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoRejQuotes *) x));
}
static void *_p_FIX__TotNoCxldQuotesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoCxldQuotes *) x));
}
static void *_p_FIX__ProductComplexTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ProductComplex *) x));
}
static void *_p_FIX__DerivativeProductComplexTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeProductComplex *) x));
}
static void *_p_FIX__TextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Text *) x));
}
static void *_p_FIX__CustOrderCapacityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CustOrderCapacity *) x));
}
static void *_p_FIX__DealingCapacityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DealingCapacity *) x));
}
static void *_p_FIX__OrigCustOrderCapacityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrigCustOrderCapacity *) x));
}
static void *_p_FIX__OrderCapacityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrderCapacity *) x));
}
static void *_p_FIX__AllocCustomerCapacityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocCustomerCapacity *) x));
}
static void *_p_FIX__LastCapacityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LastCapacity *) x));
}
static void *_p_FIX__PoolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Pool *) x));
}
static void *_p_FIX__LiquidityNumSecuritiesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LiquidityNumSecurities *) x));
}
static void *_p_FIX__TotalNumSecuritiesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalNumSecurities *) x));
}
static void *_p_FIX__RegistEmailTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistEmail *) x));
}
static void *_p_FIX__ComplianceIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ComplianceID *) x));
}
static void *_p_FIX__SideComplianceIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideComplianceID *) x));
}
static void *_p_FIX__EndSeqNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EndSeqNo *) x));
}
static void *_p_FIX__SettlPartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlPartySubID *) x));
}
static void *_p_FIX__PartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartySubID *) x));
}
static void *_p_FIX__RootPartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RootPartySubID *) x));
}
static void *_p_FIX__Nested2PartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested2PartySubID *) x));
}
static void *_p_FIX__InstrumentPartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrumentPartySubID *) x));
}
static void *_p_FIX__NestedPartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NestedPartySubID *) x));
}
static void *_p_FIX__StreamAsgnAckTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnAckType *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingInstrumentPartySubID *) x));
}
static void *_p_FIX__Nested4PartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested4PartySubID *) x));
}
static void *_p_FIX__Nested3PartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested3PartySubID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrumentPartySubID *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UndlyInstrumentPartySubID *) x));
}
static void *_p_FIX__TrdRegTimestampOriginTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TrdRegTimestampOrigin *) x));
}
static void *_p_FIX__CashDistribPayRefTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribPayRef *) x));
}
static void *_p_FIX__AdvIdTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AdvId *) x));
}
static void *_p_FIX__RegistAcctTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistAcctType *) x));
}
static void *_p_FIX__DistribPercentageTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DistribPercentage *) x));
}
static void *_p_FIX__ListIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListID *) x));
}
static void *_p_FIX__NoMarketSegmentsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMarketSegments *) x));
}
static void *_p_FIX__IOIOthSvcTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOIOthSvc *) x));
}
static void *_p_FIX__ExchangeRuleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExchangeRule *) x));
}
static void *_p_FIX__RefTagIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefTagID *) x));
}
static void *_p_FIX__ReceivedDeptIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ReceivedDeptID *) x));
}
static void *_p_FIX__ProgRptReqsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ProgRptReqs *) x));
}
static void *_p_FIX__ListSeqNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListSeqNo *) x));
}
static void *_p_FIX__CustDirectedOrderTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::CustDirectedOrder *) x));
}
static void *_p_FIX__MDStreamIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDStreamID *) x));
}
static void *_p_FIX__MDEntrySizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntrySize *) x));
}
static void *_p_FIX__TargetStrategyPerformanceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TargetStrategyPerformance *) x));
}
static void *_p_FIX__RptSysTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RptSys *) x));
}
static void *_p_FIX__LegQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegQty *) x));
}
static void *_p_FIX__EFPTrackingErrorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EFPTrackingError *) x));
}
static void *_p_FIX__MktBidPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MktBidPx *) x));
}
static void *_p_FIX__StreamAsgnRptIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StreamAsgnRptID *) x));
}
static void *_p_FIX__AsgnRptIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AsgnRptID *) x));
}
static void *_p_FIX__MaxFloorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxFloor *) x));
}
static void *_p_FIX__AllocInterestAtMaturityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocInterestAtMaturity *) x));
}
static void *_p_FIX__InterestAtMaturityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::InterestAtMaturity *) x));
}
static void *_p_FIX__SecondaryExecIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryExecID *) x));
}
static void *_p_FIX__SideExecIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideExecID *) x));
}
static void *_p_FIX__MDSecSizeTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDSecSizeType *) x));
}
static void *_p_FIX__CustomerOrFirmTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CustomerOrFirm *) x));
}
static void *_p_FIX__EncodedSecurityDescLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedSecurityDescLen *) x));
}
static void *_p_FIX__EncodedSecurityListDescLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedSecurityListDescLen *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedUnderlyingSecurityDescLen *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeEncodedSecurityDescLen *) x));
}
static void *_p_FIX__EncodedMktSegmDescLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedMktSegmDescLen *) x));
}
static void *_p_FIX__EncodedLegSecurityDescLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedLegSecurityDescLen *) x));
}
static void *_p_FIX__MDEntryOriginatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryOriginator *) x));
}
static void *_p_FIX__FutSettDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FutSettDate *) x));
}
static void *_p_FIX__LegFutSettDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegFutSettDate *) x));
}
static void *_p_FIX__BidDescriptorTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BidDescriptorType *) x));
}
static void *_p_FIX__NoMiscFeesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoMiscFees *) x));
}
static void *_p_FIX__PegMoveTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegMoveType *) x));
}
static void *_p_FIX__DiscretionMoveTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionMoveType *) x));
}
static void *_p_FIX__ClientIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClientID *) x));
}
static void *_p_FIX__RawDataLengthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RawDataLength *) x));
}
static void *_p_FIX__BodyLengthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BodyLength *) x));
}
static void *_p_FIX__SignatureLengthTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SignatureLength *) x));
}
static void *_p_FIX__OrderRestrictionsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrderRestrictions *) x));
}
static void *_p_FIX__ExchangeSpecialInstructionsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExchangeSpecialInstructions *) x));
}
static void *_p_FIX__NoClearingInstructionsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoClearingInstructions *) x));
}
static void *_p_FIX__MDEntrySellerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntrySeller *) x));
}
static void *_p_FIX__MDSecSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDSecSize *) x));
}
static void *_p_FIX__MinLotSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinLotSize *) x));
}
static void *_p_FIX__UnderlyingMaturityDayTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityDay *) x));
}
static void *_p_FIX__MaturityDayTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityDay *) x));
}
static void *_p_FIX__MassActionResponseTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionResponse *) x));
}
static void *_p_FIX__MassCancelResponseTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MassCancelResponse *) x));
}
static void *_p_FIX__SideFillStationCdTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SideFillStationCd *) x));
}
static void *_p_FIX__IOISharesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIShares *) x));
}
static void *_p_FIX__AllocSharesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocShares *) x));
}
static void *_p_FIX__PartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PartyID *) x));
}
static void *_p_FIX__Nested4PartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested4PartyID *) x));
}
static void *_p_FIX__SettlPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlPartyID *) x));
}
static void *_p_FIX__Nested3PartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested3PartyID *) x));
}
static void *_p_FIX__NestedPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NestedPartyID *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingInstrumentPartyID *) x));
}
static void *_p_FIX__TargetPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetPartyID *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UndlyInstrumentPartyID *) x));
}
static void *_p_FIX__RootPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RootPartyID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeInstrumentPartyID *) x));
}
static void *_p_FIX__InstrumentPartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InstrumentPartyID *) x));
}
static void *_p_FIX__Nested2PartyIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Nested2PartyID *) x));
}
static void *_p_FIX__CcyAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CcyAmt *) x));
}
static void *_p_FIX__ApplQueueResolutionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueResolution *) x));
}
static void *_p_FIX__DayAvgPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DayAvgPx *) x));
}
static void *_p_FIX__NoHopsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoHops *) x));
}
static void *_p_FIX__IOIIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIID *) x));
}
static void *_p_FIX__SecurityXMLLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityXMLLen *) x));
}
static void *_p_FIX__DerivativeSecurityXMLLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeSecurityXMLLen *) x));
}
static void *_p_FIX__NoRoutingIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRoutingIDs *) x));
}
static void *_p_FIX__MDEntryIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryID *) x));
}
static void *_p_FIX__QuoteEntryIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteEntryID *) x));
}
static void *_p_FIX__FillExecIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FillExecID *) x));
}
static void *_p_FIX__ExecIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecID *) x));
}
static void *_p_FIX__InvestorCountryOfResidenceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::InvestorCountryOfResidence *) x));
}
static void *_p_FIX__SpreadTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Spread *) x));
}
static void *_p_FIX__PriorSpreadIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PriorSpreadIndicator *) x));
}
static void *_p_FIX__RefreshIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::RefreshIndicator *) x));
}
static void *_p_FIX__DefaultVerIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::DefaultVerIndicator *) x));
}
static void *_p_FIX__TradeAllocIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeAllocIndicator *) x));
}
static void *_p_FIX__TrdRepIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::TrdRepIndicator *) x));
}
static void *_p_FIX__PublishTrdIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PublishTrdIndicator *) x));
}
static void *_p_FIX__TradePublishIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradePublishIndicator *) x));
}
static void *_p_FIX__CopyMsgIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::CopyMsgIndicator *) x));
}
static void *_p_FIX__AllocClearingFeeIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocClearingFeeIndicator *) x));
}
static void *_p_FIX__ImpliedMarketIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ImpliedMarketIndicator *) x));
}
static void *_p_FIX__UnsolicitedIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::UnsolicitedIndicator *) x));
}
static void *_p_FIX__LateIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LateIndicator *) x));
}
static void *_p_FIX__FlexibleIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::FlexibleIndicator *) x));
}
static void *_p_FIX__ClearingFeeIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingFeeIndicator *) x));
}
static void *_p_FIX__AutoAcceptIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::AutoAcceptIndicator *) x));
}
static void *_p_FIX__AsOfIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AsOfIndicator *) x));
}
static void *_p_FIX__DerivFlexProductEligibilityIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::DerivFlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__AvgPxIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AvgPxIndicator *) x));
}
static void *_p_FIX__TestMessageIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::TestMessageIndicator *) x));
}
static void *_p_FIX__WorkingIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::WorkingIndicator *) x));
}
static void *_p_FIX__NoTradingSessionRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTradingSessionRules *) x));
}
static void *_p_FIX__ManualOrderIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ManualOrderIndicator *) x));
}
static void *_p_FIX__ContraryInstructionIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ContraryInstructionIndicator *) x));
}
static void *_p_FIX__ReversalIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ReversalIndicator *) x));
}
static void *_p_FIX__PriorityIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PriorityIndicator *) x));
}
static void *_p_FIX__FlexProductEligibilityIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::FlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__AggressorIndicatorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::AggressorIndicator *) x));
}
static void *_p_FIX__AgreementIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AgreementID *) x));
}
static void *_p_FIX__MarketSegmentIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketSegmentID *) x));
}
static void *_p_FIX__ComplexEventPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ComplexEventPrice *) x));
}
static void *_p_FIX__ContraBrokerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContraBroker *) x));
}
static void *_p_FIX__ExecBrokerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExecBroker *) x));
}
static void *_p_FIX__SettlCurrFxRateCalcTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlCurrFxRateCalc *) x));
}
static void *_p_FIX__UnderlyingFXRateCalcTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::UnderlyingFXRateCalc *) x));
}
static void *_p_FIX__ExDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ExDate *) x));
}
static void *_p_FIX__PosMaintRptRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosMaintRptRefID *) x));
}
static void *_p_FIX__TradeReportRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeReportRefID *) x));
}
static void *_p_FIX__AllocReportRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocReportRefID *) x));
}
static void *_p_FIX__SecondaryTradeReportRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryTradeReportRefID *) x));
}
static void *_p_FIX__Price2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Price2 *) x));
}
static void *_p_FIX__ExpirationCycleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExpirationCycle *) x));
}
static void *_p_FIX__ResetSeqNumFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ResetSeqNumFlag *) x));
}
static void *_p_FIX__YieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Yield *) x));
}
static void *_p_FIX__PriorSettlPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PriorSettlPrice *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingSettlPrice *) x));
}
static void *_p_FIX__SettlPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlPrice *) x));
}
static void *_p_FIX__SideLiquidityIndTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SideLiquidityInd *) x));
}
static void *_p_FIX__LastLiquidityIndTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LastLiquidityInd *) x));
}
static void *_p_FIX__FillLiquidityIndTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::FillLiquidityInd *) x));
}
static void *_p_FIX__LegIssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIssuer *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedUnderlyingIssuer *) x));
}
static void *_p_FIX__DerivativeIssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeIssuer *) x));
}
static void *_p_FIX__UnderlyingIssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingIssuer *) x));
}
static void *_p_FIX__EncodedLegIssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedLegIssuer *) x));
}
static void *_p_FIX__TradingSessionDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingSessionDesc *) x));
}
static void *_p_FIX__StreamAsgnReqTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnReqType *) x));
}
static void *_p_FIX__AllocIntermedReqTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocIntermedReqType *) x));
}
static void *_p_FIX__PosReqTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosReqType *) x));
}
static void *_p_FIX__MassStatusReqTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassStatusReqType *) x));
}
static void *_p_FIX__ApplReqTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplReqType *) x));
}
static void *_p_FIX__LastSharesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastShares *) x));
}
static void *_p_FIX__UnderlyingFXRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingFXRate *) x));
}
static void *_p_FIX__SharesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Shares *) x));
}
static void *_p_FIX__UnderlyingLegSecurityExchangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityExchange *) x));
}
static void *_p_FIX__UnderlyingSecurityExchangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityExchange *) x));
}
static void *_p_FIX__SecurityExchangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityExchange *) x));
}
static void *_p_FIX__LegSecurityExchangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityExchange *) x));
}
static void *_p_FIX__DerivativeSecurityExchangeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityExchange *) x));
}
static void *_p_FIX__YieldTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::YieldType *) x));
}
static void *_p_FIX__CardIssNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardIssNo *) x));
}
static void *_p_FIX__UnderlyingEndPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingEndPrice *) x));
}
static void *_p_FIX__AllocQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocQty *) x));
}
static void *_p_FIX__LegAllocQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegAllocQty *) x));
}
static void *_p_FIX__ConfirmIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ConfirmID *) x));
}
static void *_p_FIX__PartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PartySubIDType *) x));
}
static void *_p_FIX__InstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::InstrumentPartySubIDType *) x));
}
static void *_p_FIX__RootPartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RootPartySubIDType *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeInstrumentPartySubIDType *) x));
}
static void *_p_FIX__Nested2PartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested2PartySubIDType *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UndlyInstrumentPartySubIDType *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingInstrumentPartySubIDType *) x));
}
static void *_p_FIX__SettlPartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlPartySubIDType *) x));
}
static void *_p_FIX__Nested3PartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested3PartySubIDType *) x));
}
static void *_p_FIX__NestedPartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NestedPartySubIDType *) x));
}
static void *_p_FIX__Nested4PartySubIDTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Nested4PartySubIDType *) x));
}
static void *_p_FIX__SolicitedFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::SolicitedFlag *) x));
}
static void *_p_FIX__MiscFeeAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MiscFeeAmt *) x));
}
static void *_p_FIX__YieldRedemptionDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::YieldRedemptionDate *) x));
}
static void *_p_FIX__UnderlyingRedemptionDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingRedemptionDate *) x));
}
static void *_p_FIX__LegRedemptionDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegRedemptionDate *) x));
}
static void *_p_FIX__TradeOriginationDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeOriginationDate *) x));
}
static void *_p_FIX__RedemptionDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RedemptionDate *) x));
}
static void *_p_FIX__StatusTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StatusText *) x));
}
static void *_p_FIX__UserStatusTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UserStatusText *) x));
}
static void *_p_FIX__ListStatusTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListStatusText *) x));
}
static void *_p_FIX__EncodedListStatusTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedListStatusText *) x));
}
static void *_p_FIX__OutsideIndexPctTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OutsideIndexPct *) x));
}
static void *_p_FIX__NoPosAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPosAmt *) x));
}
static void *_p_FIX__HeadlineTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Headline *) x));
}
static void *_p_FIX__EncodedHeadlineTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedHeadline *) x));
}
static void *_p_FIX__AttachmentPointTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AttachmentPoint *) x));
}
static void *_p_FIX__DetachmentPointTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DetachmentPoint *) x));
}
static void *_p_FIX__UnderlyingAttachmentPointTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingAttachmentPoint *) x));
}
static void *_p_FIX__UnderlyingDetachmentPointTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingDetachmentPoint *) x));
}
static void *_p_FIX__DatedDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DatedDate *) x));
}
static void *_p_FIX__TotalVolumeTradedDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcDateField *) ((FIX::TotalVolumeTradedDate *) x));
}
static void *_p_FIX__LegDatedDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegDatedDate *) x));
}
static void *_p_FIX__LegIOIQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIOIQty *) x));
}
static void *_p_FIX__LastRptRequestedTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LastRptRequested *) x));
}
static void *_p_FIX__UnderlyingCouponRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCouponRate *) x));
}
static void *_p_FIX__RefApplIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefApplID *) x));
}
static void *_p_FIX__ApplIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplID *) x));
}
static void *_p_FIX__CouponRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CouponRate *) x));
}
static void *_p_FIX__LegCouponRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegCouponRate *) x));
}
static void *_p_FIX__NoSideTrdRegTSTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSideTrdRegTS *) x));
}
static void *_p_FIX__LowLimitPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LowLimitPrice *) x));
}
static void *_p_FIX__SecondaryLowLimitPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryLowLimitPrice *) x));
}
static void *_p_FIX__HighLimitPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::HighLimitPrice *) x));
}
static void *_p_FIX__SecondaryHighLimitPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryHighLimitPrice *) x));
}
static void *_p_FIX__UnderlyingStartValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingStartValue *) x));
}
static void *_p_FIX__UnderlyingCurrentValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCurrentValue *) x));
}
static void *_p_FIX__NoApplIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoApplIDs *) x));
}
static void *_p_FIX__SecuritySettlAgentNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentName *) x));
}
static void *_p_FIX__CashDistribAgentNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentName *) x));
}
static void *_p_FIX__CashSettlAgentNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentName *) x));
}
static void *_p_FIX__RegistRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistRefID *) x));
}
static void *_p_FIX__BusinessRejectRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BusinessRejectRefID *) x));
}
static void *_p_FIX__SettlInstRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstRefID *) x));
}
static void *_p_FIX__SecurityListRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityListRefID *) x));
}
static void *_p_FIX__DerivativeCapPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeCapPrice *) x));
}
static void *_p_FIX__CapPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CapPrice *) x));
}
static void *_p_FIX__IntFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::IntField *) x));
}
static void *_p_FIX__CashSettlAgentContactPhoneTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentContactPhone *) x));
}
static void *_p_FIX__SecuritySettlAgentContactPhoneTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentContactPhone *) x));
}
static void *_p_FIX__RoundLotTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RoundLot *) x));
}
static void *_p_FIX__RejectTextTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RejectText *) x));
}
static void *_p_FIX__HopRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::HopRefID *) x));
}
static void *_p_FIX__LegExerciseStyleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegExerciseStyle *) x));
}
static void *_p_FIX__ExerciseStyleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExerciseStyle *) x));
}
static void *_p_FIX__StrikeExerciseStyleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrikeExerciseStyle *) x));
}
static void *_p_FIX__NoStrikesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStrikes *) x));
}
static void *_p_FIX__TotNoStrikesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoStrikes *) x));
}
static void *_p_FIX__DerivativeExerciseStyleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeExerciseStyle *) x));
}
static void *_p_FIX__UnderlyingExerciseStyleTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingExerciseStyle *) x));
}
static void *_p_FIX__NoAsgnReqsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAsgnReqs *) x));
}
static void *_p_FIX__IssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::Issuer *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEncodedIssuer *) x));
}
static void *_p_FIX__EncodedIssuerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedIssuer *) x));
}
static void *_p_FIX__FillPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FillPx *) x));
}
static void *_p_FIX__CheckSumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CheckSumField *) ((FIX::CheckSum *) x));
}
static void *_p_FIX__OfferYieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferYield *) x));
}
static void *_p_FIX__PeggedPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PeggedPrice *) x));
}
static void *_p_FIX__UnderlyingEndValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingEndValue *) x));
}
static void *_p_FIX__DeliverToLocationIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DeliverToLocationID *) x));
}
static void *_p_FIX__TargetLocationIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetLocationID *) x));
}
static void *_p_FIX__LocationIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LocationID *) x));
}
static void *_p_FIX__SenderLocationIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SenderLocationID *) x));
}
static void *_p_FIX__OnBehalfOfLocationIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OnBehalfOfLocationID *) x));
}
static void *_p_FIX__URLLinkTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::URLLink *) x));
}
static void *_p_FIX__CashDistribCurrTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribCurr *) x));
}
static void *_p_FIX__ContingencyTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContingencyType *) x));
}
static void *_p_FIX__PosReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PosReqID *) x));
}
static void *_p_FIX__TradSesReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradSesReqID *) x));
}
static void *_p_FIX__MassStatusReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MassStatusReqID *) x));
}
static void *_p_FIX__OrdStatusReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrdStatusReqID *) x));
}
static void *_p_FIX__QuoteStatusReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteStatusReqID *) x));
}
static void *_p_FIX__SecurityStatusReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityStatusReqID *) x));
}
static void *_p_FIX__TotalTakedownTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalTakedown *) x));
}
static void *_p_FIX__PosAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PosAmt *) x));
}
static void *_p_FIX__ProgPeriodIntervalTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ProgPeriodInterval *) x));
}
static void *_p_FIX__UnderlyingRepurchaseRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingRepurchaseRate *) x));
}
static void *_p_FIX__RepurchaseRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RepurchaseRate *) x));
}
static void *_p_FIX__LegRepurchaseRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegRepurchaseRate *) x));
}
static void *_p_FIX__LastParPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastParPx *) x));
}
static void *_p_FIX__BeginStringTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BeginString *) x));
}
static void *_p_FIX__NoDistribInstsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDistribInsts *) x));
}
static void *_p_FIX__LiquidityPctLowTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LiquidityPctLow *) x));
}
static void *_p_FIX__CardIssNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardIssNum *) x));
}
static void *_p_FIX__MsgTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MsgType *) x));
}
static void *_p_FIX__RefMsgTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefMsgType *) x));
}
static void *_p_FIX__TotNoFillsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoFills *) x));
}
static void *_p_FIX__NoFillsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoFills *) x));
}
static void *_p_FIX__TradSesPreCloseTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesPreCloseTime *) x));
}
static void *_p_FIX__TradSesCloseTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TradSesCloseTime *) x));
}
static void *_p_FIX__IOIQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIQty *) x));
}
static void *_p_FIX__DisplayHighQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayHighQty *) x));
}
static void *_p_FIX__BidDescriptorTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BidDescriptor *) x));
}
static void *_p_FIX__ParticipationRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ParticipationRate *) x));
}
static void *_p_FIX__CollAsgnRespTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnRespType *) x));
}
static void *_p_FIX__QuoteRespTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteRespType *) x));
}
static void *_p_FIX__BuyVolumeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BuyVolume *) x));
}
static void *_p_FIX__TradeVolumeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TradeVolume *) x));
}
static void *_p_FIX__TotalNetValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalNetValue *) x));
}
static void *_p_FIX__DiscretionOffsetValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DiscretionOffsetValue *) x));
}
static void *_p_FIX__ExecInstValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecInstValue *) x));
}
static void *_p_FIX__ContAmtValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ContAmtValue *) x));
}
static void *_p_FIX__PegOffsetValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PegOffsetValue *) x));
}
static void *_p_FIX__StrikeTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::StrikeTime *) x));
}
static void *_p_FIX__HeartBtIntTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::HeartBtInt *) x));
}
static void *_p_FIX__UnderlyingStipValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingStipValue *) x));
}
static void *_p_FIX__UnderlyingCapValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCapValue *) x));
}
static void *_p_FIX__EncryptedPasswordLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptedPasswordLen *) x));
}
static void *_p_FIX__EncryptedNewPasswordLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptedNewPasswordLen *) x));
}
static void *_p_FIX__FeeMultiplierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FeeMultiplier *) x));
}
static void *_p_FIX__ContractMultiplierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ContractMultiplier *) x));
}
static void *_p_FIX__LegContractMultiplierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegContractMultiplier *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingContractMultiplier *) x));
}
static void *_p_FIX__StrikeMultiplierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikeMultiplier *) x));
}
static void *_p_FIX__DerivativeContractMultiplierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeContractMultiplier *) x));
}
static void *_p_FIX__DerivativeStrikeMultiplierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeStrikeMultiplier *) x));
}
static void *_p_FIX__RegistRejReasonCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RegistRejReasonCode *) x));
}
static void *_p_FIX__ForexReqTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ForexReq *) x));
}
static void *_p_FIX__SettlSessIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlSessID *) x));
}
static void *_p_FIX__UtcTimeStampFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcTimeStampField *) x));
}
static void *_p_FIX__OddLotTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::OddLot *) x));
}
static void *_p_FIX__LanguageCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LanguageCode *) x));
}
static void *_p_FIX__NewsRefTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NewsRefType *) x));
}
static void *_p_FIX__EncodedSubjectLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncodedSubjectLen *) x));
}
static void *_p_FIX__TotalVolumeTradedTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeOnlyField *) ((FIX::TotalVolumeTradedTime *) x));
}
static void *_p_FIX__TotalVolumeTradedTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalVolumeTraded *) x));
}
static void *_p_FIX__NoContraBrokersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoContraBrokers *) x));
}
static void *_p_FIX__OutMainCntryUIndexTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OutMainCntryUIndex *) x));
}
static void *_p_FIX__BoolFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::BoolField *) x));
}
static void *_p_FIX__UnderlyingPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingPx *) x));
}
static void *_p_FIX__ContraTraderTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContraTrader *) x));
}
static void *_p_FIX__NoTradesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTrades *) x));
}
static void *_p_FIX__AllowableOneSidednessPctTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllowableOneSidednessPct *) x));
}
static void *_p_FIX__MsgSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MsgSeqNum *) x));
}
static void *_p_FIX__NextExpectedMsgSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NextExpectedMsgSeqNum *) x));
}
static void *_p_FIX__ApplNewSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplNewSeqNum *) x));
}
static void *_p_FIX__LegVolatilityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegVolatility *) x));
}
static void *_p_FIX__VolatilityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Volatility *) x));
}
static void *_p_FIX__ApplBegSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplBegSeqNum *) x));
}
static void *_p_FIX__NoNewsRefIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNewsRefIDs *) x));
}
static void *_p_FIX__ContAmtCurrTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ContAmtCurr *) x));
}
static void *_p_FIX__StandInstDbTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StandInstDbType *) x));
}
static void *_p_FIX__ClearingInstructionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ClearingInstruction *) x));
}
static void *_p_FIX__LastMktTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LastMkt *) x));
}
static void *_p_FIX__SecurityResponseTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityResponseType *) x));
}
static void *_p_FIX__ApplResponseTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplResponseType *) x));
}
static void *_p_FIX__NetworkStatusResponseTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NetworkStatusResponseType *) x));
}
static void *_p_FIX__SecondaryAllocIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryAllocID *) x));
}
static void *_p_FIX__IndividualAllocIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IndividualAllocID *) x));
}
static void *_p_FIX__RefAllocIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefAllocID *) x));
}
static void *_p_FIX__AllocIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllocID *) x));
}
static void *_p_FIX__SecondaryIndividualAllocIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryIndividualAllocID *) x));
}
static void *_p_FIX__LegAllocIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegAllocID *) x));
}
static void *_p_FIX__LegIndividualAllocIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegIndividualAllocID *) x));
}
static void *_p_FIX__EmailThreadIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EmailThreadID *) x));
}
static void *_p_FIX__SellVolumeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SellVolume *) x));
}
static void *_p_FIX__LegSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityDesc *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeEncodedSecurityDesc *) x));
}
static void *_p_FIX__DerivativeSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityDesc *) x));
}
static void *_p_FIX__TriggerSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSecurityDesc *) x));
}
static void *_p_FIX__EncodedLegSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedLegSecurityDesc *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedUnderlyingSecurityDesc *) x));
}
static void *_p_FIX__SecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityDesc *) x));
}
static void *_p_FIX__UnderlyingSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityDesc *) x));
}
static void *_p_FIX__EncodedSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EncodedSecurityDesc *) x));
}
static void *_p_FIX__UnderlyingLegSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityDesc *) x));
}
static void *_p_FIX__PegSecurityDescTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSecurityDesc *) x));
}
static void *_p_FIX__NoComplexEventTimesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoComplexEventTimes *) x));
}
static void *_p_FIX__CardExpDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CardExpDate *) x));
}
static void *_p_FIX__AllocAccruedInterestAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocAccruedInterestAmt *) x));
}
static void *_p_FIX__AccruedInterestAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AccruedInterestAmt *) x));
}
static void *_p_FIX__TotalAccruedInterestAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TotalAccruedInterestAmt *) x));
}
static void *_p_FIX__EndAccruedInterestAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndAccruedInterestAmt *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingContractMultiplierUnit *) x));
}
static void *_p_FIX__ContractMultiplierUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ContractMultiplierUnit *) x));
}
static void *_p_FIX__LegContractMultiplierUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegContractMultiplierUnit *) x));
}
static void *_p_FIX__DerivativeContractMultiplierUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeContractMultiplierUnit *) x));
}
static void *_p_FIX__LegSideTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegSide *) x));
}
static void *_p_FIX__TargetStrategyParametersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TargetStrategyParameters *) x));
}
static void *_p_FIX__BidIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BidID *) x));
}
static void *_p_FIX__NoStrategyParametersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoStrategyParameters *) x));
}
static void *_p_FIX__NoCapacitiesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoCapacities *) x));
}
static void *_p_FIX__UnderlyingMaturityDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityDate *) x));
}
static void *_p_FIX__LegMaturityDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegMaturityDate *) x));
}
static void *_p_FIX__DerivativeMaturityDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeMaturityDate *) x));
}
static void *_p_FIX__QuantityDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuantityDate *) x));
}
static void *_p_FIX__UnderlyingLegMaturityDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegMaturityDate *) x));
}
static void *_p_FIX__MaturityDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityDate *) x));
}
static void *_p_FIX__MsgDirectionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MsgDirection *) x));
}
static void *_p_FIX__PegRoundDirectionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegRoundDirection *) x));
}
static void *_p_FIX__RoundingDirectionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RoundingDirection *) x));
}
static void *_p_FIX__TickDirectionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TickDirection *) x));
}
static void *_p_FIX__TriggerPriceDirectionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerPriceDirection *) x));
}
static void *_p_FIX__DiscretionRoundDirectionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DiscretionRoundDirection *) x));
}
static void *_p_FIX__WaveNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::WaveNo *) x));
}
static void *_p_FIX__HighPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::HighPx *) x));
}
static void *_p_FIX__PossResendTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PossResend *) x));
}
static void *_p_FIX__AvgPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AvgPx *) x));
}
static void *_p_FIX__RateSourceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RateSourceType *) x));
}
static void *_p_FIX__SecurityGroupTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityGroup *) x));
}
static void *_p_FIX__DerivativeSecurityGroupTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityGroup *) x));
}
static void *_p_FIX__TotNoOrdersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoOrders *) x));
}
static void *_p_FIX__NoOrdersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOrders *) x));
}
static void *_p_FIX__PosReqResultTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosReqResult *) x));
}
static void *_p_FIX__CollInquiryResultTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollInquiryResult *) x));
}
static void *_p_FIX__PegDifferenceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PegDifference *) x));
}
static void *_p_FIX__MDUpdateActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MDUpdateAction *) x));
}
static void *_p_FIX__MarketUpdateActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MarketUpdateAction *) x));
}
static void *_p_FIX__ApplQueueActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplQueueAction *) x));
}
static void *_p_FIX__SecurityUpdateActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SecurityUpdateAction *) x));
}
static void *_p_FIX__ListUpdateActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ListUpdateAction *) x));
}
static void *_p_FIX__TradSesUpdateActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TradSesUpdateAction *) x));
}
static void *_p_FIX__CorporateActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CorporateAction *) x));
}
static void *_p_FIX__NewsIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NewsID *) x));
}
static void *_p_FIX__PreviouslyReportedTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PreviouslyReported *) x));
}
static void *_p_FIX__MaxTradeVolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxTradeVol *) x));
}
static void *_p_FIX__MinTradeVolTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinTradeVol *) x));
}
static void *_p_FIX__DiscretionInstTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DiscretionInst *) x));
}
static void *_p_FIX__AllowableOneSidednessCurrTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AllowableOneSidednessCurr *) x));
}
static void *_p_FIX__AllocNoOrdersTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocNoOrdersType *) x));
}
static void *_p_FIX__ConfirmStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmStatus *) x));
}
static void *_p_FIX__QuoteStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteStatus *) x));
}
static void *_p_FIX__SecurityStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityStatus *) x));
}
static void *_p_FIX__QuoteEntryStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteEntryStatus *) x));
}
static void *_p_FIX__AffirmStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AffirmStatus *) x));
}
static void *_p_FIX__TradSesStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesStatus *) x));
}
static void *_p_FIX__QuoteAckStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuoteAckStatus *) x));
}
static void *_p_FIX__PosQtyStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosQtyStatus *) x));
}
static void *_p_FIX__CollInquiryStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollInquiryStatus *) x));
}
static void *_p_FIX__SecurityTradingStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityTradingStatus *) x));
}
static void *_p_FIX__AllocStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocStatus *) x));
}
static void *_p_FIX__PosReqStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosReqStatus *) x));
}
static void *_p_FIX__MoneyLaunderingStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MoneyLaunderingStatus *) x));
}
static void *_p_FIX__DerivativeSecurityStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityStatus *) x));
}
static void *_p_FIX__ExecAckStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecAckStatus *) x));
}
static void *_p_FIX__ApplEndSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplEndSeqNum *) x));
}
static void *_p_FIX__ApplSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplSeqNum *) x));
}
static void *_p_FIX__ApplLastSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplLastSeqNum *) x));
}
static void *_p_FIX__RefSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefSeqNum *) x));
}
static void *_p_FIX__RefApplLastSeqNumTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefApplLastSeqNum *) x));
}
static void *_p_FIX__OrderBookingQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderBookingQty *) x));
}
static void *_p_FIX__UnderlyingQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingQty *) x));
}
static void *_p_FIX__UnderlyingCPProgramTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingCPProgram *) x));
}
static void *_p_FIX__CPProgramTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CPProgram *) x));
}
static void *_p_FIX__MDEntryPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntryPx *) x));
}
static void *_p_FIX__PosTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosTransType *) x));
}
static void *_p_FIX__SettlObligTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlObligTransType *) x));
}
static void *_p_FIX__ConfirmTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ConfirmTransType *) x));
}
static void *_p_FIX__IOITransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOITransType *) x));
}
static void *_p_FIX__AllocTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AllocTransType *) x));
}
static void *_p_FIX__AdvTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::AdvTransType *) x));
}
static void *_p_FIX__CollAsgnTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAsgnTransType *) x));
}
static void *_p_FIX__TradeReportTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeReportTransType *) x));
}
static void *_p_FIX__RegistTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RegistTransType *) x));
}
static void *_p_FIX__SettlInstTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlInstTransType *) x));
}
static void *_p_FIX__BidRequestTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::BidRequestTransType *) x));
}
static void *_p_FIX__ExecTransTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecTransType *) x));
}
static void *_p_FIX__BidForwardPoints2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidForwardPoints2 *) x));
}
static void *_p_FIX__OfferForwardPoints2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferForwardPoints2 *) x));
}
static void *_p_FIX__LastForwardPoints2To_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastForwardPoints2 *) x));
}
static void *_p_FIX__CollAsgnIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollAsgnID *) x));
}
static void *_p_FIX__OpenCloseTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OpenClose *) x));
}
static void *_p_FIX__AllocPositionEffectTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AllocPositionEffect *) x));
}
static void *_p_FIX__LegPositionEffectTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::LegPositionEffect *) x));
}
static void *_p_FIX__PositionEffectTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PositionEffect *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoUndlyInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoNested2PartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested2PartySubIDs *) x));
}
static void *_p_FIX__NoPartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartySubIDs *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoDerivativeInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoSettlPartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlPartySubIDs *) x));
}
static void *_p_FIX__NoNested3PartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested3PartySubIDs *) x));
}
static void *_p_FIX__NoNested4PartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested4PartySubIDs *) x));
}
static void *_p_FIX__NoNestedPartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNestedPartySubIDs *) x));
}
static void *_p_FIX__NoRootPartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRootPartySubIDs *) x));
}
static void *_p_FIX__NoInstrumentPartySubIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoInstrumentPartySubIDs *) x));
}
static void *_p_FIX__IncTaxIndTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::IncTaxInd *) x));
}
static void *_p_FIX__RepurchaseTermTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RepurchaseTerm *) x));
}
static void *_p_FIX__UnderlyingRepurchaseTermTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingRepurchaseTerm *) x));
}
static void *_p_FIX__LegRepurchaseTermTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegRepurchaseTerm *) x));
}
static void *_p_FIX__RelatdSymTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RelatdSym *) x));
}
static void *_p_FIX__OpenCloseSettleFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OpenCloseSettleFlag *) x));
}
static void *_p_FIX__RefApplExtIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::RefApplExtID *) x));
}
static void *_p_FIX__DefaultApplExtIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DefaultApplExtID *) x));
}
static void *_p_FIX__ApplExtIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ApplExtID *) x));
}
static void *_p_FIX__RegistDetlsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RegistDetls *) x));
}
static void *_p_FIX__SenderSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SenderSubID *) x));
}
static void *_p_FIX__SettlObligModeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlObligMode *) x));
}
static void *_p_FIX__StipulationTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::StipulationType *) x));
}
static void *_p_FIX__LegStipulationTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegStipulationType *) x));
}
static void *_p_FIX__MassActionTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MassActionType *) x));
}
static void *_p_FIX__TerminationTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TerminationType *) x));
}
static void *_p_FIX__SettlObligIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlObligID *) x));
}
static void *_p_FIX__NotAffOrigClOrdIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::NotAffOrigClOrdID *) x));
}
static void *_p_FIX__OrigClOrdIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigClOrdID *) x));
}
static void *_p_FIX__ClOrdIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClOrdID *) x));
}
static void *_p_FIX__SecondaryClOrdIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecondaryClOrdID *) x));
}
static void *_p_FIX__PaymentRemitterIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PaymentRemitterID *) x));
}
static void *_p_FIX__BidTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BidType *) x));
}
static void *_p_FIX__UnderlyingTradingSessionSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingTradingSessionSubID *) x));
}
static void *_p_FIX__TriggerTradingSessionSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerTradingSessionSubID *) x));
}
static void *_p_FIX__TradingSessionSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradingSessionSubID *) x));
}
static void *_p_FIX__MarketIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketID *) x));
}
static void *_p_FIX__TaxAdvantageTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TaxAdvantageType *) x));
}
static void *_p_FIX__NoSettlDetailsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlDetails *) x));
}
static void *_p_FIX__DayCumQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DayCumQty *) x));
}
static void *_p_FIX__MDEntryPositionNoTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MDEntryPositionNo *) x));
}
static void *_p_FIX__LegPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegPriceType *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingSettlPriceType *) x));
}
static void *_p_FIX__TriggerPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerPriceType *) x));
}
static void *_p_FIX__SettlPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SettlPriceType *) x));
}
static void *_p_FIX__LegBenchmarkPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegBenchmarkPriceType *) x));
}
static void *_p_FIX__PegPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PegPriceType *) x));
}
static void *_p_FIX__YieldRedemptionPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::YieldRedemptionPriceType *) x));
}
static void *_p_FIX__QuotePriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::QuotePriceType *) x));
}
static void *_p_FIX__PriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PriceType *) x));
}
static void *_p_FIX__ExecPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExecPriceType *) x));
}
static void *_p_FIX__BenchmarkPriceTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::BenchmarkPriceType *) x));
}
static void *_p_FIX__StreamAsgnTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StreamAsgnType *) x));
}
static void *_p_FIX__NumberOfOrdersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NumberOfOrders *) x));
}
static void *_p_FIX__NoAffectedOrdersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoAffectedOrders *) x));
}
static void *_p_FIX__NoNotAffectedOrdersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNotAffectedOrders *) x));
}
static void *_p_FIX__TotalAffectedOrdersTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotalAffectedOrders *) x));
}
static void *_p_FIX__SecurityRequestResultTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecurityRequestResult *) x));
}
static void *_p_FIX__PosMaintResultTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosMaintResult *) x));
}
static void *_p_FIX__TradeRequestResultTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeRequestResult *) x));
}
static void *_p_FIX__OrderDelayUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::OrderDelayUnit *) x));
}
static void *_p_FIX__EndCashTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::EndCash *) x));
}
static void *_p_FIX__CollActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollAction *) x));
}
static void *_p_FIX__TriggerActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerAction *) x));
}
static void *_p_FIX__PosMaintActionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosMaintAction *) x));
}
static void *_p_FIX__RefSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefSubID *) x));
}
static void *_p_FIX__OnBehalfOfSubIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OnBehalfOfSubID *) x));
}
static void *_p_FIX__UnderlyingDirtyPriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingDirtyPrice *) x));
}
static void *_p_FIX__OrderCapacityQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderCapacityQty *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegSecurityID *) x));
}
static void *_p_FIX__UnderlyingSecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSecurityID *) x));
}
static void *_p_FIX__PegSecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PegSecurityID *) x));
}
static void *_p_FIX__TriggerSecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TriggerSecurityID *) x));
}
static void *_p_FIX__LegSecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSecurityID *) x));
}
static void *_p_FIX__SecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecurityID *) x));
}
static void *_p_FIX__DerivativeSecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeSecurityID *) x));
}
static void *_p_FIX__BenchmarkSecurityIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkSecurityID *) x));
}
static void *_p_FIX__PosMaintStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PosMaintStatus *) x));
}
static void *_p_FIX__MatchStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::MatchStatus *) x));
}
static void *_p_FIX__CollStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollStatus *) x));
}
static void *_p_FIX__FinancialStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FinancialStatus *) x));
}
static void *_p_FIX__TrdRptStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TrdRptStatus *) x));
}
static void *_p_FIX__UserStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UserStatus *) x));
}
static void *_p_FIX__RegistStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::RegistStatus *) x));
}
static void *_p_FIX__ListOrderStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListOrderStatus *) x));
}
static void *_p_FIX__TradeRequestStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradeRequestStatus *) x));
}
static void *_p_FIX__SessionStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SessionStatus *) x));
}
static void *_p_FIX__UnderlyingSettlementStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSettlementStatus *) x));
}
static void *_p_FIX__OrdStatusTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrdStatus *) x));
}
static void *_p_FIX__OrderAvgPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OrderAvgPx *) x));
}
static void *_p_FIX__XmlDataLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::XmlDataLen *) x));
}
static void *_p_FIX__MDEntryRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryRefID *) x));
}
static void *_p_FIX__SecureDataLenTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::SecureDataLen *) x));
}
static void *_p_FIX__MultiLegRptTypeReqTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MultiLegRptTypeReq *) x));
}
static void *_p_FIX__MaturityTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MaturityTime *) x));
}
static void *_p_FIX__UnderlyingMaturityTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingMaturityTime *) x));
}
static void *_p_FIX__DerivativeMaturityTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeMaturityTime *) x));
}
static void *_p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingLegMaturityTime *) x));
}
static void *_p_FIX__LegMaturityTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegMaturityTime *) x));
}
static void *_p_FIX__NoTickRulesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTickRules *) x));
}
static void *_p_FIX__ClearingBusinessDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ClearingBusinessDate *) x));
}
static void *_p_FIX__PositionLimitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PositionLimit *) x));
}
static void *_p_FIX__DerivativeNTPositionLimitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeNTPositionLimit *) x));
}
static void *_p_FIX__NTPositionLimitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NTPositionLimit *) x));
}
static void *_p_FIX__DerivativePositionLimitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativePositionLimit *) x));
}
static void *_p_FIX__QuoteSetIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::QuoteSetID *) x));
}
static void *_p_FIX__QuantityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Quantity *) x));
}
static void *_p_FIX__UnderlyingAdjustedQuantityTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingAdjustedQuantity *) x));
}
static void *_p_FIX__UnderlyingPayAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingPayAmount *) x));
}
static void *_p_FIX__DerivativeOptPayAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeOptPayAmount *) x));
}
static void *_p_FIX__UnderlyingDeliveryAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingDeliveryAmount *) x));
}
static void *_p_FIX__OptPayAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OptPayAmount *) x));
}
static void *_p_FIX__ConfirmRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ConfirmRefID *) x));
}
static void *_p_FIX__NoContAmtsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoContAmts *) x));
}
static void *_p_FIX__IndividualAllocTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::IndividualAllocType *) x));
}
static void *_p_FIX__AllocTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocType *) x));
}
static void *_p_FIX__SharedCommissionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SharedCommission *) x));
}
static void *_p_FIX__CommissionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Commission *) x));
}
static void *_p_FIX__UnderlyingOriginalNotionalPercentageOutstandingTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingOriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__DiscretionOffsetTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DiscretionOffset *) x));
}
static void *_p_FIX__MidPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MidPx *) x));
}
static void *_p_FIX__IOIRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::IOIRefID *) x));
}
static void *_p_FIX__BasisFeaturePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BasisFeaturePrice *) x));
}
static void *_p_FIX__UnderlyingProductTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingProduct *) x));
}
static void *_p_FIX__DerivativeProductTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeProduct *) x));
}
static void *_p_FIX__LegProductTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::LegProduct *) x));
}
static void *_p_FIX__ProductTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::Product *) x));
}
static void *_p_FIX__LocateReqdTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::LocateReqd *) x));
}
static void *_p_FIX__ConcessionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::Concession *) x));
}
static void *_p_FIX__CommTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::CommType *) x));
}
static void *_p_FIX__MaxPriceVariationTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxPriceVariation *) x));
}
static void *_p_FIX__CumQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CumQty *) x));
}
static void *_p_FIX__TradeHandlingInstrTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TradeHandlingInstr *) x));
}
static void *_p_FIX__OrigTradeHandlingInstrTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::OrigTradeHandlingInstr *) x));
}
static void *_p_FIX__MDFeedTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDFeedType *) x));
}
static void *_p_FIX__TriggerPriceTypeScopeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::TriggerPriceTypeScope *) x));
}
static void *_p_FIX__NetChgPrevDayTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::NetChgPrevDay *) x));
}
static void *_p_FIX__TrdRegTimestampTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::TrdRegTimestamp *) x));
}
static void *_p_FIX__SideTrdRegTimestampTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::SideTrdRegTimestamp *) x));
}
static void *_p_FIX__AssignmentUnitTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AssignmentUnit *) x));
}
static void *_p_FIX__TradSesMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TradSesMethod *) x));
}
static void *_p_FIX__DisplayMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DisplayMethod *) x));
}
static void *_p_FIX__PriceQuoteMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::PriceQuoteMethod *) x));
}
static void *_p_FIX__StrikePriceBoundaryMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrikePriceBoundaryMethod *) x));
}
static void *_p_FIX__PreallocMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::PreallocMethod *) x));
}
static void *_p_FIX__DerivativePriceQuoteMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativePriceQuoteMethod *) x));
}
static void *_p_FIX__AllocMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AllocMethod *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ComplexEventPriceBoundaryMethod *) x));
}
static void *_p_FIX__MultilegPriceMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MultilegPriceMethod *) x));
}
static void *_p_FIX__ExerciseMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ExerciseMethod *) x));
}
static void *_p_FIX__CollReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CollReqID *) x));
}
static void *_p_FIX__RefApplReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::RefApplReqID *) x));
}
static void *_p_FIX__ApplReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ApplReqID *) x));
}
static void *_p_FIX__NoBidComponentsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoBidComponents *) x));
}
static void *_p_FIX__LiquidityValueTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LiquidityValue *) x));
}
static void *_p_FIX__OrigTradeDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigTradeDate *) x));
}
static void *_p_FIX__TradeDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TradeDate *) x));
}
static void *_p_FIX__ListNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ListName *) x));
}
static void *_p_FIX__PctAtRiskTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::PctAtRisk *) x));
}
static void *_p_FIX__UtcTimeOnlyFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcTimeOnlyField *) x));
}
static void *_p_FIX__TotNoRelatedSymTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TotNoRelatedSym *) x));
}
static void *_p_FIX__NoRelatedSymTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRelatedSym *) x));
}
static void *_p_FIX__MDReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDReqID *) x));
}
static void *_p_FIX__LegCurrencyRatioTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegCurrencyRatio *) x));
}
static void *_p_FIX__CurrencyRatioTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::CurrencyRatio *) x));
}
static void *_p_FIX__AllocNetMoneyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::AllocNetMoney *) x));
}
static void *_p_FIX__NetMoneyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::NetMoney *) x));
}
static void *_p_FIX__MaturityNetMoneyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaturityNetMoney *) x));
}
static void *_p_FIX__RatioQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::RatioQty *) x));
}
static void *_p_FIX__LegRatioQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegRatioQty *) x));
}
static void *_p_FIX__BenchmarkCurveNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkCurveName *) x));
}
static void *_p_FIX__LegBenchmarkCurveNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegBenchmarkCurveName *) x));
}
static void *_p_FIX__OrigPosReqRefIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigPosReqRefID *) x));
}
static void *_p_FIX__AggregatedBookTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::AggregatedBook *) x));
}
static void *_p_FIX__LegBenchmarkCurvePointTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegBenchmarkCurvePoint *) x));
}
static void *_p_FIX__BenchmarkCurvePointTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::BenchmarkCurvePoint *) x));
}
static void *_p_FIX__MinPriceIncrementAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinPriceIncrementAmount *) x));
}
static void *_p_FIX__OptPayoutAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OptPayoutAmount *) x));
}
static void *_p_FIX__UnderlyingCollectAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCollectAmount *) x));
}
static void *_p_FIX__ComplexOptPayoutAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ComplexOptPayoutAmount *) x));
}
static void *_p_FIX__ThresholdAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ThresholdAmount *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeMinPriceIncrementAmount *) x));
}
static void *_p_FIX__UnderlyingCashAmountTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingCashAmount *) x));
}
static void *_p_FIX__OpenCloseSettlFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OpenCloseSettlFlag *) x));
}
static void *_p_FIX__ApplResendFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::ApplResendFlag *) x));
}
static void *_p_FIX__DisplayMinIncrTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DisplayMinIncr *) x));
}
static void *_p_FIX__MaxShowTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MaxShow *) x));
}
static void *_p_FIX__NoExecsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoExecs *) x));
}
static void *_p_FIX__SettlCurrFxRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrFxRate *) x));
}
static void *_p_FIX__SettlCurrOfferFxRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrOfferFxRate *) x));
}
static void *_p_FIX__SettlCurrBidFxRateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SettlCurrBidFxRate *) x));
}
static void *_p_FIX__DeliveryFormTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DeliveryForm *) x));
}
static void *_p_FIX__HostCrossIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::HostCrossID *) x));
}
static void *_p_FIX__OrigCrossIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::OrigCrossID *) x));
}
static void *_p_FIX__CrossIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CrossID *) x));
}
static void *_p_FIX__TargetStrategyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::TargetStrategy *) x));
}
static void *_p_FIX__SecuritySettlAgentContactNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentContactName *) x));
}
static void *_p_FIX__CashSettlAgentAcctNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentAcctName *) x));
}
static void *_p_FIX__CashDistribAgentAcctNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashDistribAgentAcctName *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SecuritySettlAgentAcctName *) x));
}
static void *_p_FIX__NoPartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoPartyIDs *) x));
}
static void *_p_FIX__NoRootPartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoRootPartyIDs *) x));
}
static void *_p_FIX__NoTargetPartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoTargetPartyIDs *) x));
}
static void *_p_FIX__NoNested4PartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested4PartyIDs *) x));
}
static void *_p_FIX__NoSettlPartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoSettlPartyIDs *) x));
}
static void *_p_FIX__NoNestedPartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNestedPartyIDs *) x));
}
static void *_p_FIX__NoNested2PartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested2PartyIDs *) x));
}
static void *_p_FIX__NoNested3PartyIDsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoNested3PartyIDs *) x));
}
static void *_p_FIX__CashSettlAgentContactNameTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::CashSettlAgentContactName *) x));
}
static void *_p_FIX__FirstPxTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::FirstPx *) x));
}
static void *_p_FIX__NoOfSecSizesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoOfSecSizes *) x));
}
static void *_p_FIX__UnderlyingLegStrikePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingLegStrikePrice *) x));
}
static void *_p_FIX__LegStrikePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegStrikePrice *) x));
}
static void *_p_FIX__DerivativeStrikePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DerivativeStrikePrice *) x));
}
static void *_p_FIX__SecondaryTradingReferencePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SecondaryTradingReferencePrice *) x));
}
static void *_p_FIX__UnderlyingStrikePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::UnderlyingStrikePrice *) x));
}
static void *_p_FIX__StrikePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikePrice *) x));
}
static void *_p_FIX__TradingReferencePriceTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::TradingReferencePrice *) x));
}
static void *_p_FIX__StrikePriceBoundaryPrecisionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::StrikePriceBoundaryPrecision *) x));
}
static void *_p_FIX__AvgPrxPrecisionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AvgPrxPrecision *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ComplexEventPriceBoundaryPrecision *) x));
}
static void *_p_FIX__AvgPxPrecisionTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::AvgPxPrecision *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementUnitsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaturityMonthYearIncrementUnits *) x));
}
static void *_p_FIX__MDEntryBuyerTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MDEntryBuyer *) x));
}
static void *_p_FIX__LegSettlDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::LegSettlDate *) x));
}
static void *_p_FIX__SettlDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlDate *) x));
}
static void *_p_FIX__LeavesQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LeavesQty *) x));
}
static void *_p_FIX__ComplexEventEndDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::ComplexEventEndDate *) x));
}
static void *_p_FIX__EndDateTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::EndDate *) x));
}
static void *_p_FIX__SettlInstReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::SettlInstReqID *) x));
}
static void *_p_FIX__MarketReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::MarketReqID *) x));
}
static void *_p_FIX__TestReqIDTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::TestReqID *) x));
}
static void *_p_FIX__NestedInstrAttribTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NestedInstrAttribType *) x));
}
static void *_p_FIX__DerivativeInstrAttribTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeInstrAttribType *) x));
}
static void *_p_FIX__InstrAttribTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::InstrAttribType *) x));
}
static void *_p_FIX__ProcessCodeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::ProcessCode *) x));
}
static void *_p_FIX__UtcDateFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::UtcDateField *) x));
}
static void *_p_FIX__DoubleFieldTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *)  ((FIX::DoubleField *) x));
}
static void *_p_FIX__ValueOfFuturesTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ValueOfFutures *) x));
}
static void *_p_FIX__QuoteQualifierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::QuoteQualifier *) x));
}
static void *_p_FIX__IOIQualifierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::IOIQualifier *) x));
}
static void *_p_FIX__CollInquiryQualifierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::CollInquiryQualifier *) x));
}
static void *_p_FIX__NoCollInquiryQualifierTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::NoCollInquiryQualifier *) x));
}
static void *_p_FIX__ExpQtyTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::ExpQty *) x));
}
static void *_p_FIX__LegGrossTradeAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegGrossTradeAmt *) x));
}
static void *_p_FIX__GrossTradeAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::GrossTradeAmt *) x));
}
static void *_p_FIX__SideGrossTradeAmtTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SideGrossTradeAmt *) x));
}
static void *_p_FIX__MinBidSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MinBidSize *) x));
}
static void *_p_FIX__DefBidSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::DefBidSize *) x));
}
static void *_p_FIX__BidSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidSize *) x));
}
static void *_p_FIX__ExpTypeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ExpType *) x));
}
static void *_p_FIX__LastUpdateTimeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::UtcTimeStampField *) ((FIX::LastUpdateTime *) x));
}
static void *_p_FIX__PossDupFlagTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::BoolField *) ((FIX::PossDupFlag *) x));
}
static void *_p_FIX__EncryptedPasswordMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptedPasswordMethod *) x));
}
static void *_p_FIX__DerivativeSettlMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeSettlMethod *) x));
}
static void *_p_FIX__InstrmtAssignmentMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::InstrmtAssignmentMethod *) x));
}
static void *_p_FIX__DerivativeValuationMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeValuationMethod *) x));
}
static void *_p_FIX__DerivativeInstrmtAssignmentMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::DerivativeInstrmtAssignmentMethod *) x));
}
static void *_p_FIX__SettlMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::SettlMethod *) x));
}
static void *_p_FIX__FuturesValuationMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::FuturesValuationMethod *) x));
}
static void *_p_FIX__UnderlyingPriceDeterminationMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::UnderlyingPriceDeterminationMethod *) x));
}
static void *_p_FIX__PaymentMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::PaymentMethod *) x));
}
static void *_p_FIX__StrikePriceDeterminationMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::StrikePriceDeterminationMethod *) x));
}
static void *_p_FIX__DistribPaymentMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DistribPaymentMethod *) x));
}
static void *_p_FIX__ValuationMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::ValuationMethod *) x));
}
static void *_p_FIX__DerivativeFuturesValuationMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::DerivativeFuturesValuationMethod *) x));
}
static void *_p_FIX__ListMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::ListMethod *) x));
}
static void *_p_FIX__AssignmentMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::AssignmentMethod *) x));
}
static void *_p_FIX__EncryptMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::EncryptMethod *) x));
}
static void *_p_FIX__UnderlyingSettlMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::StringField *) ((FIX::UnderlyingSettlMethod *) x));
}
static void *_p_FIX__LastForwardPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastForwardPoints *) x));
}
static void *_p_FIX__SwapPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::SwapPoints *) x));
}
static void *_p_FIX__LegLastForwardPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegLastForwardPoints *) x));
}
static void *_p_FIX__LegOfferForwardPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegOfferForwardPoints *) x));
}
static void *_p_FIX__BidSwapPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidSwapPoints *) x));
}
static void *_p_FIX__OfferSwapPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferSwapPoints *) x));
}
static void *_p_FIX__BidForwardPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::BidForwardPoints *) x));
}
static void *_p_FIX__MDEntryForwardPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::MDEntryForwardPoints *) x));
}
static void *_p_FIX__OfferForwardPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::OfferForwardPoints *) x));
}
static void *_p_FIX__MaxMessageSizeTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::MaxMessageSize *) x));
}
static void *_p_FIX__LegBidForwardPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LegBidForwardPoints *) x));
}
static void *_p_FIX__DerivativeListMethodTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::IntField *) ((FIX::DerivativeListMethod *) x));
}
static void *_p_FIX__LastSwapPointsTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::DoubleField *) ((FIX::LastSwapPoints *) x));
}
static void *_p_FIX__SideTo_p_FIX__FieldBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::FieldBase *) (FIX::CharField *) ((FIX::Side *) x));
}
static void *_p_FIX__MemoryStoreTo_p_FIX__MessageStore(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStore *)  ((FIX::MemoryStore *) x));
}
static void *_p_FIX__FileStoreTo_p_FIX__MessageStore(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStore *)  ((FIX::FileStore *) x));
}
static void *_p_FIX__ScreenLogFactoryTo_p_FIX__LogFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::LogFactory *)  ((FIX::ScreenLogFactory *) x));
}
static void *_p_FIX__FileLogFactoryTo_p_FIX__LogFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::LogFactory *)  ((FIX::FileLogFactory *) x));
}
static void *_p_FIX__MemoryStoreFactoryTo_p_FIX__MessageStoreFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStoreFactory *)  ((FIX::MemoryStoreFactory *) x));
}
static void *_p_FIX__FileStoreFactoryTo_p_FIX__MessageStoreFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::MessageStoreFactory *)  ((FIX::FileStoreFactory *) x));
}
static void *_p_FIX__DeliveryDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DeliveryDate *) x));
}
static void *_p_FIX__RFQReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RFQReqID *) x));
}
static void *_p_FIX__TradeConditionTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeCondition *) x));
}
static void *_p_FIX__EncodedTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedText *) x));
}
static void *_p_FIX__QuoteConditionTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteCondition *) x));
}
static void *_p_FIX__ExchangeRuleTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExchangeRule *) x));
}
static void *_p_FIX__FutSettDate2To_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::FutSettDate2 *) x));
}
static void *_p_FIX__CollAsgnIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CollAsgnID *) x));
}
static void *_p_FIX__TradeRequestIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeRequestID *) x));
}
static void *_p_FIX__UserRequestIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UserRequestID *) x));
}
static void *_p_FIX__NetworkRequestIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NetworkRequestID *) x));
}
static void *_p_FIX__ClientBidIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClientBidID *) x));
}
static void *_p_FIX__ReferencePageTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ReferencePage *) x));
}
static void *_p_FIX__UserStatusTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UserStatusText *) x));
}
static void *_p_FIX__MDFeedTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDFeedType *) x));
}
static void *_p_FIX__StatusTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StatusText *) x));
}
static void *_p_FIX__ListStatusTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ListStatusText *) x));
}
static void *_p_FIX__EncodedListStatusTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedListStatusText *) x));
}
static void *_p_FIX__DeskTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DeskType *) x));
}
static void *_p_FIX__SettlDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlDate *) x));
}
static void *_p_FIX__LegSettlDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSettlDate *) x));
}
static void *_p_FIX__PriceUnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PriceUnitOfMeasure *) x));
}
static void *_p_FIX__UnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnitOfMeasure *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativePriceUnitOfMeasure *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeUnitOfMeasure *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegPriceUnitOfMeasure *) x));
}
static void *_p_FIX__LegUnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegUnitOfMeasure *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingUnitOfMeasure *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingPriceUnitOfMeasure *) x));
}
static void *_p_FIX__TransferReasonTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TransferReason *) x));
}
static void *_p_FIX__InstrRegistryTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::InstrRegistry *) x));
}
static void *_p_FIX__LegInstrRegistryTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegInstrRegistry *) x));
}
static void *_p_FIX__DerivativeInstrRegistryTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrRegistry *) x));
}
static void *_p_FIX__UnderlyingInstrRegistryTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingInstrRegistry *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEncodedSecurityDesc *) x));
}
static void *_p_FIX__DerivativeSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityDesc *) x));
}
static void *_p_FIX__TriggerSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSecurityDesc *) x));
}
static void *_p_FIX__PegSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PegSecurityDesc *) x));
}
static void *_p_FIX__UnderlyingLegSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityDesc *) x));
}
static void *_p_FIX__UnderlyingSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityDesc *) x));
}
static void *_p_FIX__SecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityDesc *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedUnderlyingSecurityDesc *) x));
}
static void *_p_FIX__EncodedLegSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedLegSecurityDesc *) x));
}
static void *_p_FIX__EncodedSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedSecurityDesc *) x));
}
static void *_p_FIX__LegSecurityDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityDesc *) x));
}
static void *_p_FIX__UsernameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Username *) x));
}
static void *_p_FIX__SettlBrkrCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlBrkrCode *) x));
}
static void *_p_FIX__TextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Text *) x));
}
static void *_p_FIX__RegistRejReasonTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RegistRejReasonText *) x));
}
static void *_p_FIX__ApplIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ApplID *) x));
}
static void *_p_FIX__RefApplIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefApplID *) x));
}
static void *_p_FIX__SideTrdRegTimestampSrcTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideTrdRegTimestampSrc *) x));
}
static void *_p_FIX__SendingDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SendingDate *) x));
}
static void *_p_FIX__UndlyInstrumentPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UndlyInstrumentPartyID *) x));
}
static void *_p_FIX__TargetPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TargetPartyID *) x));
}
static void *_p_FIX__NestedPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NestedPartyID *) x));
}
static void *_p_FIX__Nested3PartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Nested3PartyID *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingInstrumentPartyID *) x));
}
static void *_p_FIX__CollInquiryIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CollInquiryID *) x));
}
static void *_p_FIX__SettlPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlPartyID *) x));
}
static void *_p_FIX__Nested4PartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Nested4PartyID *) x));
}
static void *_p_FIX__PartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PartyID *) x));
}
static void *_p_FIX__RootPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RootPartyID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrumentPartyID *) x));
}
static void *_p_FIX__InstrumentPartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::InstrumentPartyID *) x));
}
static void *_p_FIX__Nested2PartyIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Nested2PartyID *) x));
}
static void *_p_FIX__SettlSessIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlSessID *) x));
}
static void *_p_FIX__MarketSegmentDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MarketSegmentDesc *) x));
}
static void *_p_FIX__AgreementDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementDesc *) x));
}
static void *_p_FIX__QuoteReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteReqID *) x));
}
static void *_p_FIX__ExecIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExecID *) x));
}
static void *_p_FIX__FillExecIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::FillExecID *) x));
}
static void *_p_FIX__SecondaryExecIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryExecID *) x));
}
static void *_p_FIX__SideExecIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideExecID *) x));
}
static void *_p_FIX__CashSettlAgentNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentName *) x));
}
static void *_p_FIX__CashDistribAgentNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentName *) x));
}
static void *_p_FIX__SecuritySettlAgentNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentName *) x));
}
static void *_p_FIX__MDEntryOriginatorTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryOriginator *) x));
}
static void *_p_FIX__LegStipulationTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegStipulationType *) x));
}
static void *_p_FIX__PoolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Pool *) x));
}
static void *_p_FIX__StipulationTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StipulationType *) x));
}
static void *_p_FIX__SettlInstCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstCode *) x));
}
static void *_p_FIX__MailingDtlsTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MailingDtls *) x));
}
static void *_p_FIX__LegSecurityAltIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityAltID *) x));
}
static void *_p_FIX__SecurityAltIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityAltID *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityAltID *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityAltID *) x));
}
static void *_p_FIX__EncodedAllocTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedAllocText *) x));
}
static void *_p_FIX__AllocTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocText *) x));
}
static void *_p_FIX__ClientIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClientID *) x));
}
static void *_p_FIX__TargetSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TargetSubID *) x));
}
static void *_p_FIX__RelatdSymTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RelatdSym *) x));
}
static void *_p_FIX__SecuritySettlAgentContactNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentContactName *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentAcctName *) x));
}
static void *_p_FIX__CashDistribAgentAcctNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentAcctName *) x));
}
static void *_p_FIX__CashSettlAgentAcctNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentAcctName *) x));
}
static void *_p_FIX__CashSettlAgentContactNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentContactName *) x));
}
static void *_p_FIX__ApplVerIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ApplVerID *) x));
}
static void *_p_FIX__RefCstmApplVerIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefCstmApplVerID *) x));
}
static void *_p_FIX__DefaultApplVerIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DefaultApplVerID *) x));
}
static void *_p_FIX__CstmApplVerIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CstmApplVerID *) x));
}
static void *_p_FIX__RefApplVerIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefApplVerID *) x));
}
static void *_p_FIX__DefaultCstmApplVerIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DefaultCstmApplVerID *) x));
}
static void *_p_FIX__CountryTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Country *) x));
}
static void *_p_FIX__CardHolderNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CardHolderName *) x));
}
static void *_p_FIX__StrategyParameterNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StrategyParameterName *) x));
}
static void *_p_FIX__SenderLocationIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SenderLocationID *) x));
}
static void *_p_FIX__LocationIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LocationID *) x));
}
static void *_p_FIX__TargetLocationIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TargetLocationID *) x));
}
static void *_p_FIX__OnBehalfOfLocationIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OnBehalfOfLocationID *) x));
}
static void *_p_FIX__DeliverToLocationIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DeliverToLocationID *) x));
}
static void *_p_FIX__TradeInputDeviceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeInputDevice *) x));
}
static void *_p_FIX__OrderInputDeviceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrderInputDevice *) x));
}
static void *_p_FIX__AllowableOneSidednessCurrTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllowableOneSidednessCurr *) x));
}
static void *_p_FIX__LegAllocSettlCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocSettlCurrency *) x));
}
static void *_p_FIX__PositionCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PositionCurrency *) x));
}
static void *_p_FIX__UnderlyingCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCurrency *) x));
}
static void *_p_FIX__CommCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CommCurrency *) x));
}
static void *_p_FIX__UnderlyingStrikeCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStrikeCurrency *) x));
}
static void *_p_FIX__DerivativeStrikeCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeStrikeCurrency *) x));
}
static void *_p_FIX__AgreementCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementCurrency *) x));
}
static void *_p_FIX__TradingCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradingCurrency *) x));
}
static void *_p_FIX__CurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Currency *) x));
}
static void *_p_FIX__StrikeCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StrikeCurrency *) x));
}
static void *_p_FIX__SettlCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlCurrency *) x));
}
static void *_p_FIX__LegSettlCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSettlCurrency *) x));
}
static void *_p_FIX__LegCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegCurrency *) x));
}
static void *_p_FIX__SideCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideCurrency *) x));
}
static void *_p_FIX__AllocSettlCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocSettlCurrency *) x));
}
static void *_p_FIX__BenchmarkCurveCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkCurveCurrency *) x));
}
static void *_p_FIX__LegBenchmarkCurveCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegBenchmarkCurveCurrency *) x));
}
static void *_p_FIX__SideSettlCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideSettlCurrency *) x));
}
static void *_p_FIX__LegStrikeCurrencyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegStrikeCurrency *) x));
}
static void *_p_FIX__ClearingFeeIndicatorTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingFeeIndicator *) x));
}
static void *_p_FIX__AllocClearingFeeIndicatorTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocClearingFeeIndicator *) x));
}
static void *_p_FIX__UnderlyingSettlementStatusTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSettlementStatus *) x));
}
static void *_p_FIX__FinancialStatusTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::FinancialStatus *) x));
}
static void *_p_FIX__AllocCustomerCapacityTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocCustomerCapacity *) x));
}
static void *_p_FIX__SecurityStatusTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityStatus *) x));
}
static void *_p_FIX__DerivativeSecurityStatusTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityStatus *) x));
}
static void *_p_FIX__MDReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDReqID *) x));
}
static void *_p_FIX__MDEntryRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryRefID *) x));
}
static void *_p_FIX__StandInstDbIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StandInstDbID *) x));
}
static void *_p_FIX__SettlInstMsgIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstMsgID *) x));
}
static void *_p_FIX__SignatureTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Signature *) x));
}
static void *_p_FIX__BrokerOfCreditTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BrokerOfCredit *) x));
}
static void *_p_FIX__OrigTradeDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrigTradeDate *) x));
}
static void *_p_FIX__TradeDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeDate *) x));
}
static void *_p_FIX__DatedDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DatedDate *) x));
}
static void *_p_FIX__LegDatedDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegDatedDate *) x));
}
static void *_p_FIX__CrossIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CrossID *) x));
}
static void *_p_FIX__OrigCrossIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrigCrossID *) x));
}
static void *_p_FIX__HostCrossIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::HostCrossID *) x));
}
static void *_p_FIX__CollAsgnRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CollAsgnRefID *) x));
}
static void *_p_FIX__SecurityReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityReqID *) x));
}
static void *_p_FIX__OpenCloseSettlFlagTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OpenCloseSettlFlag *) x));
}
static void *_p_FIX__AffectedSecondaryOrderIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AffectedSecondaryOrderID *) x));
}
static void *_p_FIX__RefOrderIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefOrderID *) x));
}
static void *_p_FIX__SecondaryOrderIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryOrderID *) x));
}
static void *_p_FIX__MailingInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MailingInst *) x));
}
static void *_p_FIX__NotAffectedOrderIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NotAffectedOrderID *) x));
}
static void *_p_FIX__OrderIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrderID *) x));
}
static void *_p_FIX__AffectedOrderIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AffectedOrderID *) x));
}
static void *_p_FIX__CustOrderHandlingInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CustOrderHandlingInst *) x));
}
static void *_p_FIX__DeskOrderHandlingInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DeskOrderHandlingInst *) x));
}
static void *_p_FIX__SettlSessSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlSessSubID *) x));
}
static void *_p_FIX__LegBenchmarkCurvePointTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegBenchmarkCurvePoint *) x));
}
static void *_p_FIX__BenchmarkCurvePointTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkCurvePoint *) x));
}
static void *_p_FIX__ContraTraderTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ContraTrader *) x));
}
static void *_p_FIX__PaymentRefTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PaymentRef *) x));
}
static void *_p_FIX__TradingSessionIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradingSessionID *) x));
}
static void *_p_FIX__TriggerTradingSessionIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerTradingSessionID *) x));
}
static void *_p_FIX__UnderlyingTradingSessionIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingTradingSessionID *) x));
}
static void *_p_FIX__StreamAsgnReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StreamAsgnReqID *) x));
}
static void *_p_FIX__SettlInstIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstID *) x));
}
static void *_p_FIX__ExecRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExecRefID *) x));
}
static void *_p_FIX__FutSettDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::FutSettDate *) x));
}
static void *_p_FIX__LegFutSettDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegFutSettDate *) x));
}
static void *_p_FIX__CardExpDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CardExpDate *) x));
}
static void *_p_FIX__ExDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExDate *) x));
}
static void *_p_FIX__QuoteSetIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteSetID *) x));
}
static void *_p_FIX__CashDistribAgentAcctNumberTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentAcctNumber *) x));
}
static void *_p_FIX__CardNumberTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CardNumber *) x));
}
static void *_p_FIX__LastNetworkResponseIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LastNetworkResponseID *) x));
}
static void *_p_FIX__SecurityResponseIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityResponseID *) x));
}
static void *_p_FIX__NetworkResponseIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NetworkResponseID *) x));
}
static void *_p_FIX__ApplResponseIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ApplResponseID *) x));
}
static void *_p_FIX__LastMktTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LastMkt *) x));
}
static void *_p_FIX__MDEntrySellerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntrySeller *) x));
}
static void *_p_FIX__RedemptionDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RedemptionDate *) x));
}
static void *_p_FIX__TradeOriginationDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeOriginationDate *) x));
}
static void *_p_FIX__LegRedemptionDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegRedemptionDate *) x));
}
static void *_p_FIX__SecondaryFirmTradeIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryFirmTradeID *) x));
}
static void *_p_FIX__TradeIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeID *) x));
}
static void *_p_FIX__FirmTradeIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::FirmTradeID *) x));
}
static void *_p_FIX__SecondaryTradeIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryTradeID *) x));
}
static void *_p_FIX__OrigTradeIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrigTradeID *) x));
}
static void *_p_FIX__UnderlyingRedemptionDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingRedemptionDate *) x));
}
static void *_p_FIX__YieldRedemptionDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::YieldRedemptionDate *) x));
}
static void *_p_FIX__OrigSecondaryTradeIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrigSecondaryTradeID *) x));
}
static void *_p_FIX__InvestorCountryOfResidenceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::InvestorCountryOfResidence *) x));
}
static void *_p_FIX__CreditRatingTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CreditRating *) x));
}
static void *_p_FIX__LegCreditRatingTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegCreditRating *) x));
}
static void *_p_FIX__UnderlyingCreditRatingTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCreditRating *) x));
}
static void *_p_FIX__ConfirmRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ConfirmRefID *) x));
}
static void *_p_FIX__MDEntryBuyerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryBuyer *) x));
}
static void *_p_FIX__IOIIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IOIID *) x));
}
static void *_p_FIX__UnderlyingCashTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCashType *) x));
}
static void *_p_FIX__SenderSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SenderSubID *) x));
}
static void *_p_FIX__TrdRegTimestampOriginTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TrdRegTimestampOrigin *) x));
}
static void *_p_FIX__AdvIdTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AdvId *) x));
}
static void *_p_FIX__TrdMatchIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TrdMatchID *) x));
}
static void *_p_FIX__ConfirmReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ConfirmReqID *) x));
}
static void *_p_FIX__MaturityRuleIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityRuleID *) x));
}
static void *_p_FIX__StrikeRuleIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StrikeRuleID *) x));
}
static void *_p_FIX__TriggerSecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSecurityID *) x));
}
static void *_p_FIX__LegSecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityID *) x));
}
static void *_p_FIX__SecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityID *) x));
}
static void *_p_FIX__DerivativeSecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityID *) x));
}
static void *_p_FIX__BenchmarkSecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkSecurityID *) x));
}
static void *_p_FIX__PegSecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PegSecurityID *) x));
}
static void *_p_FIX__UnderlyingSecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityID *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityID *) x));
}
static void *_p_FIX__RefCompIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefCompID *) x));
}
static void *_p_FIX__SenderCompIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SenderCompID *) x));
}
static void *_p_FIX__TargetCompIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TargetCompID *) x));
}
static void *_p_FIX__HopCompIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::HopCompID *) x));
}
static void *_p_FIX__OnBehalfOfCompIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OnBehalfOfCompID *) x));
}
static void *_p_FIX__CashSettlAgentContactPhoneTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentContactPhone *) x));
}
static void *_p_FIX__SecuritySettlAgentContactPhoneTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentContactPhone *) x));
}
static void *_p_FIX__DeliverToCompIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DeliverToCompID *) x));
}
static void *_p_FIX__ConfirmIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ConfirmID *) x));
}
static void *_p_FIX__EndDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EndDate *) x));
}
static void *_p_FIX__LegStateOrProvinceOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__LegCountryOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegCountryOfIssue *) x));
}
static void *_p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__DerivativeCountryOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeCountryOfIssue *) x));
}
static void *_p_FIX__DerivativeStateOrProvinceOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeStateOrProvinceOfIssue *) x));
}
static void *_p_FIX__YieldTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::YieldType *) x));
}
static void *_p_FIX__UnderlyingCountryOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCountryOfIssue *) x));
}
static void *_p_FIX__LocaleOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LocaleOfIssue *) x));
}
static void *_p_FIX__LegLocaleOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegLocaleOfIssue *) x));
}
static void *_p_FIX__StateOrProvinceOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StateOrProvinceOfIssue *) x));
}
static void *_p_FIX__CountryOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CountryOfIssue *) x));
}
static void *_p_FIX__DerivativeLocaleOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeLocaleOfIssue *) x));
}
static void *_p_FIX__UnderlyingLocaleOfIssueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLocaleOfIssue *) x));
}
static void *_p_FIX__SymbolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Symbol *) x));
}
static void *_p_FIX__TriggerSymbolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSymbol *) x));
}
static void *_p_FIX__UnderlyingLegSymbolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSymbol *) x));
}
static void *_p_FIX__PegSymbolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PegSymbol *) x));
}
static void *_p_FIX__UnderlyingSymbolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSymbol *) x));
}
static void *_p_FIX__LegSymbolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSymbol *) x));
}
static void *_p_FIX__DerivativeSymbolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSymbol *) x));
}
static void *_p_FIX__AltMDSourceIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AltMDSourceID *) x));
}
static void *_p_FIX__StrategyParameterValueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StrategyParameterValue *) x));
}
static void *_p_FIX__UnderlyingSettlMethodTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSettlMethod *) x));
}
static void *_p_FIX__DerivativeFuturesValuationMethodTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeFuturesValuationMethod *) x));
}
static void *_p_FIX__ValuationMethodTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ValuationMethod *) x));
}
static void *_p_FIX__BeginStringTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BeginString *) x));
}
static void *_p_FIX__FuturesValuationMethodTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::FuturesValuationMethod *) x));
}
static void *_p_FIX__DerivativeValuationMethodTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeValuationMethod *) x));
}
static void *_p_FIX__DerivativePriceQuoteMethodTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativePriceQuoteMethod *) x));
}
static void *_p_FIX__PriceQuoteMethodTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PriceQuoteMethod *) x));
}
static void *_p_FIX__WaveNoTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::WaveNo *) x));
}
static void *_p_FIX__RegistDtlsTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RegistDtls *) x));
}
static void *_p_FIX__PasswordTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Password *) x));
}
static void *_p_FIX__NewPasswordTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NewPassword *) x));
}
static void *_p_FIX__EncryptedNewPasswordTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncryptedNewPassword *) x));
}
static void *_p_FIX__SettlObligMsgIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlObligMsgID *) x));
}
static void *_p_FIX__EncryptedPasswordTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncryptedPassword *) x));
}
static void *_p_FIX__IOIQtyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IOIQty *) x));
}
static void *_p_FIX__MessageEncodingTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MessageEncoding *) x));
}
static void *_p_FIX__LegIOIQtyTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegIOIQty *) x));
}
static void *_p_FIX__RefMsgTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefMsgType *) x));
}
static void *_p_FIX__MsgTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MsgType *) x));
}
static void *_p_FIX__EncodedMktSegmDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedMktSegmDesc *) x));
}
static void *_p_FIX__SettleOnOpenFlagTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettleOnOpenFlag *) x));
}
static void *_p_FIX__DerivativeSettleOnOpenFlagTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSettleOnOpenFlag *) x));
}
static void *_p_FIX__RefApplReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefApplReqID *) x));
}
static void *_p_FIX__ApplReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ApplReqID *) x));
}
static void *_p_FIX__CollReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CollReqID *) x));
}
static void *_p_FIX__DerivativeSecurityXMLTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityXML *) x));
}
static void *_p_FIX__SecurityXMLTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityXML *) x));
}
static void *_p_FIX__TargetStrategyParametersTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TargetStrategyParameters *) x));
}
static void *_p_FIX__BidIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BidID *) x));
}
static void *_p_FIX__DerivativeSecurityGroupTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityGroup *) x));
}
static void *_p_FIX__UnderlyingSeniorityTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSeniority *) x));
}
static void *_p_FIX__StartDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StartDate *) x));
}
static void *_p_FIX__SecurityGroupTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityGroup *) x));
}
static void *_p_FIX__CardStartDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CardStartDate *) x));
}
static void *_p_FIX__SeniorityTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Seniority *) x));
}
static void *_p_FIX__RefSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefSubID *) x));
}
static void *_p_FIX__OnBehalfOfSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OnBehalfOfSubID *) x));
}
static void *_p_FIX__ClearingBusinessDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingBusinessDate *) x));
}
static void *_p_FIX__ListIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ListID *) x));
}
static void *_p_FIX__MatchAlgorithmTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MatchAlgorithm *) x));
}
static void *_p_FIX__SecurityListIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityListID *) x));
}
static void *_p_FIX__CashDistribPayRefTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribPayRef *) x));
}
static void *_p_FIX__LegExecInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegExecInst *) x));
}
static void *_p_FIX__EncodedListExecInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedListExecInst *) x));
}
static void *_p_FIX__ExecInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExecInst *) x));
}
static void *_p_FIX__ListExecInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ListExecInst *) x));
}
static void *_p_FIX__SecondaryClOrdIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryClOrdID *) x));
}
static void *_p_FIX__ClOrdIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClOrdID *) x));
}
static void *_p_FIX__OrigClOrdIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrigClOrdID *) x));
}
static void *_p_FIX__NotAffOrigClOrdIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NotAffOrigClOrdID *) x));
}
static void *_p_FIX__AdvRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AdvRefID *) x));
}
static void *_p_FIX__URLLinkTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::URLLink *) x));
}
static void *_p_FIX__SideReasonCdTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideReasonCd *) x));
}
static void *_p_FIX__UnderlyingStipTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStipType *) x));
}
static void *_p_FIX__PaymentRemitterIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PaymentRemitterID *) x));
}
static void *_p_FIX__DerivativeCFICodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeCFICode *) x));
}
static void *_p_FIX__LegCFICodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegCFICode *) x));
}
static void *_p_FIX__AsgnRptIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AsgnRptID *) x));
}
static void *_p_FIX__UnderlyingCFICodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCFICode *) x));
}
static void *_p_FIX__StreamAsgnRptIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StreamAsgnRptID *) x));
}
static void *_p_FIX__CFICodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CFICode *) x));
}
static void *_p_FIX__UnderlyingLegCFICodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegCFICode *) x));
}
static void *_p_FIX__SecondaryTradeReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryTradeReportID *) x));
}
static void *_p_FIX__ApplReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ApplReportID *) x));
}
static void *_p_FIX__SideTradeReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideTradeReportID *) x));
}
static void *_p_FIX__AllocReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocReportID *) x));
}
static void *_p_FIX__TradeReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeReportID *) x));
}
static void *_p_FIX__LegReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegReportID *) x));
}
static void *_p_FIX__MarketReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MarketReportID *) x));
}
static void *_p_FIX__MassActionReportIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MassActionReportID *) x));
}
static void *_p_FIX__RoutingIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RoutingID *) x));
}
static void *_p_FIX__IOIidTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IOIid *) x));
}
static void *_p_FIX__ExchangeSpecialInstructionsTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExchangeSpecialInstructions *) x));
}
static void *_p_FIX__OrderRestrictionsTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrderRestrictions *) x));
}
static void *_p_FIX__TimeUnitTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TimeUnit *) x));
}
static void *_p_FIX__LegTimeUnitTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegTimeUnit *) x));
}
static void *_p_FIX__DerivativeTimeUnitTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeTimeUnit *) x));
}
static void *_p_FIX__UnderlyingTimeUnitTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingTimeUnit *) x));
}
static void *_p_FIX__ExecBrokerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExecBroker *) x));
}
static void *_p_FIX__ContraBrokerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ContraBroker *) x));
}
static void *_p_FIX__NewsIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NewsID *) x));
}
static void *_p_FIX__ParentMktSegmIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ParentMktSegmID *) x));
}
static void *_p_FIX__SubjectTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Subject *) x));
}
static void *_p_FIX__EncodedSubjectTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedSubject *) x));
}
static void *_p_FIX__UnderlyingStipValueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingStipValue *) x));
}
static void *_p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityXMLSchema *) x));
}
static void *_p_FIX__SecurityXMLSchemaTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityXMLSchema *) x));
}
static void *_p_FIX__DerivativeEventTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEventText *) x));
}
static void *_p_FIX__EventTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EventText *) x));
}
static void *_p_FIX__TradingSessionDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradingSessionDesc *) x));
}
static void *_p_FIX__AllocIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocID *) x));
}
static void *_p_FIX__LegIndividualAllocIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegIndividualAllocID *) x));
}
static void *_p_FIX__LegAllocIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocID *) x));
}
static void *_p_FIX__SecondaryIndividualAllocIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryIndividualAllocID *) x));
}
static void *_p_FIX__RefAllocIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RefAllocID *) x));
}
static void *_p_FIX__IndividualAllocIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IndividualAllocID *) x));
}
static void *_p_FIX__SecondaryAllocIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryAllocID *) x));
}
static void *_p_FIX__CardIssNumTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CardIssNum *) x));
}
static void *_p_FIX__RepoCollateralSecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RepoCollateralSecurityType *) x));
}
static void *_p_FIX__LegRepoCollateralSecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegRepoCollateralSecurityType *) x));
}
static void *_p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityType *) x));
}
static void *_p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingRepoCollateralSecurityType *) x));
}
static void *_p_FIX__DerivativeSecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityType *) x));
}
static void *_p_FIX__LegSecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityType *) x));
}
static void *_p_FIX__CashDistribAgentCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribAgentCode *) x));
}
static void *_p_FIX__SecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityType *) x));
}
static void *_p_FIX__UnderlyingSecurityTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityType *) x));
}
static void *_p_FIX__SecuritySettlAgentCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentCode *) x));
}
static void *_p_FIX__CashSettlAgentCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentCode *) x));
}
static void *_p_FIX__ReceivedDeptIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ReceivedDeptID *) x));
}
static void *_p_FIX__QuoteMsgIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteMsgID *) x));
}
static void *_p_FIX__UnderlyingCPProgramTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCPProgram *) x));
}
static void *_p_FIX__DeliverToSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DeliverToSubID *) x));
}
static void *_p_FIX__RejectTextTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RejectText *) x));
}
static void *_p_FIX__IOISharesTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IOIShares *) x));
}
static void *_p_FIX__UnderlyingIssueDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingIssueDate *) x));
}
static void *_p_FIX__DerivativeIssueDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeIssueDate *) x));
}
static void *_p_FIX__IssueDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IssueDate *) x));
}
static void *_p_FIX__LegIssueDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegIssueDate *) x));
}
static void *_p_FIX__QuoteIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteID *) x));
}
static void *_p_FIX__SecurityListDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityListDesc *) x));
}
static void *_p_FIX__ClOrdLinkIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClOrdLinkID *) x));
}
static void *_p_FIX__EncodedSecurityListDescTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedSecurityListDesc *) x));
}
static void *_p_FIX__TierCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TierCode *) x));
}
static void *_p_FIX__TradeLinkIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeLinkID *) x));
}
static void *_p_FIX__AllocLinkIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocLinkID *) x));
}
static void *_p_FIX__EncodedHeadlineTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedHeadline *) x));
}
static void *_p_FIX__HeadlineTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Headline *) x));
}
static void *_p_FIX__RegistEmailTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RegistEmail *) x));
}
static void *_p_FIX__SecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityIDSource *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrumentPartyIDSource *) x));
}
static void *_p_FIX__MessageEventSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MessageEventSource *) x));
}
static void *_p_FIX__TradeInputSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeInputSource *) x));
}
static void *_p_FIX__LegSecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityIDSource *) x));
}
static void *_p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityAltIDSource *) x));
}
static void *_p_FIX__DerivativeSecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityIDSource *) x));
}
static void *_p_FIX__BenchmarkSecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkSecurityIDSource *) x));
}
static void *_p_FIX__IDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IDSource *) x));
}
static void *_p_FIX__ContAmtCurrTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ContAmtCurr *) x));
}
static void *_p_FIX__UnderlyingLegSecurityAltIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityAltIDSource *) x));
}
static void *_p_FIX__SecurityAltIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingIDSource *) x));
}
static void *_p_FIX__LegSecurityAltIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityAltIDSource *) x));
}
static void *_p_FIX__TriggerSecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerSecurityIDSource *) x));
}
static void *_p_FIX__PegSecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PegSecurityIDSource *) x));
}
static void *_p_FIX__InputSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::InputSource *) x));
}
static void *_p_FIX__UnderlyingSecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityIDSource *) x));
}
static void *_p_FIX__LegAllocAcctIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocAcctIDSource *) x));
}
static void *_p_FIX__UnderlyingSecurityAltIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityAltIDSource *) x));
}
static void *_p_FIX__UnderlyingLegSecurityIDSourceTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityIDSource *) x));
}
static void *_p_FIX__MaturityDayTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityDay *) x));
}
static void *_p_FIX__PosTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PosType *) x));
}
static void *_p_FIX__UnderlyingMaturityDayTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityDay *) x));
}
static void *_p_FIX__ComplianceIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ComplianceID *) x));
}
static void *_p_FIX__SideComplianceIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideComplianceID *) x));
}
static void *_p_FIX__ListNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ListName *) x));
}
static void *_p_FIX__ClearingFirmTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingFirm *) x));
}
static void *_p_FIX__YieldCalcDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::YieldCalcDate *) x));
}
static void *_p_FIX__OpenCloseSettleFlagTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OpenCloseSettleFlag *) x));
}
static void *_p_FIX__SecurityListRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityListRefID *) x));
}
static void *_p_FIX__SettlInstRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstRefID *) x));
}
static void *_p_FIX__BusinessRejectRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BusinessRejectRefID *) x));
}
static void *_p_FIX__RegistRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RegistRefID *) x));
}
static void *_p_FIX__TradeReportRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeReportRefID *) x));
}
static void *_p_FIX__AllocReportRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocReportRefID *) x));
}
static void *_p_FIX__PosMaintRptRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PosMaintRptRefID *) x));
}
static void *_p_FIX__SecondaryTradeReportRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecondaryTradeReportRefID *) x));
}
static void *_p_FIX__RegistAcctTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RegistAcctType *) x));
}
static void *_p_FIX__SideFillStationCdTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SideFillStationCd *) x));
}
static void *_p_FIX__Nested2PartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Nested2PartySubID *) x));
}
static void *_p_FIX__NestedPartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NestedPartySubID *) x));
}
static void *_p_FIX__InstrumentPartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::InstrumentPartySubID *) x));
}
static void *_p_FIX__QuoteEntryIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteEntryID *) x));
}
static void *_p_FIX__RootPartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RootPartySubID *) x));
}
static void *_p_FIX__MDEntryIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDEntryID *) x));
}
static void *_p_FIX__PartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PartySubID *) x));
}
static void *_p_FIX__SettlPartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlPartySubID *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingInstrumentPartySubID *) x));
}
static void *_p_FIX__Nested4PartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Nested4PartySubID *) x));
}
static void *_p_FIX__Nested3PartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Nested3PartySubID *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrumentPartySubID *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UndlyInstrumentPartySubID *) x));
}
static void *_p_FIX__XmlDataTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::XmlData *) x));
}
static void *_p_FIX__MDStreamIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDStreamID *) x));
}
static void *_p_FIX__SettlInstReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlInstReqID *) x));
}
static void *_p_FIX__MarketReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MarketReqID *) x));
}
static void *_p_FIX__CollRptIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CollRptID *) x));
}
static void *_p_FIX__TestReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TestReqID *) x));
}
static void *_p_FIX__IOIRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::IOIRefID *) x));
}
static void *_p_FIX__SecuritySettlAgentAcctNumTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySettlAgentAcctNum *) x));
}
static void *_p_FIX__CashSettlAgentAcctNumTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashSettlAgentAcctNum *) x));
}
static void *_p_FIX__LanguageCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LanguageCode *) x));
}
static void *_p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSymbolSfx *) x));
}
static void *_p_FIX__SymbolSfxTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SymbolSfx *) x));
}
static void *_p_FIX__UnderlyingTradingSessionSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingTradingSessionSubID *) x));
}
static void *_p_FIX__TradingSessionSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradingSessionSubID *) x));
}
static void *_p_FIX__TriggerTradingSessionSubIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TriggerTradingSessionSubID *) x));
}
static void *_p_FIX__DerivativeSymbolSfxTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSymbolSfx *) x));
}
static void *_p_FIX__UnderlyingSymbolSfxTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSymbolSfx *) x));
}
static void *_p_FIX__LegSymbolSfxTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSymbolSfx *) x));
}
static void *_p_FIX__AllocAccountTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AllocAccount *) x));
}
static void *_p_FIX__LegAllocAccountTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegAllocAccount *) x));
}
static void *_p_FIX__ClearingAccountTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ClearingAccount *) x));
}
static void *_p_FIX__AccountTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Account *) x));
}
static void *_p_FIX__EncodedIssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedIssuer *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEncodedIssuer *) x));
}
static void *_p_FIX__IssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Issuer *) x));
}
static void *_p_FIX__EncodedLegIssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedLegIssuer *) x));
}
static void *_p_FIX__UnderlyingIssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingIssuer *) x));
}
static void *_p_FIX__DerivativeIssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeIssuer *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EncodedUnderlyingIssuer *) x));
}
static void *_p_FIX__LegIssuerTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegIssuer *) x));
}
static void *_p_FIX__BidDescriptorTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BidDescriptor *) x));
}
static void *_p_FIX__UnderlyingLegSecuritySubTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecuritySubType *) x));
}
static void *_p_FIX__DerivativeSecuritySubTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecuritySubType *) x));
}
static void *_p_FIX__SecuritySubTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecuritySubType *) x));
}
static void *_p_FIX__LegSecuritySubTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecuritySubType *) x));
}
static void *_p_FIX__UnderlyingSecuritySubTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecuritySubType *) x));
}
static void *_p_FIX__ScopeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Scope *) x));
}
static void *_p_FIX__TimeBracketTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TimeBracket *) x));
}
static void *_p_FIX__PosAmtTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PosAmtType *) x));
}
static void *_p_FIX__AdvTransTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AdvTransType *) x));
}
static void *_p_FIX__SettlDepositoryCodeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlDepositoryCode *) x));
}
static void *_p_FIX__CPRegTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CPRegType *) x));
}
static void *_p_FIX__LegPoolTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegPool *) x));
}
static void *_p_FIX__UnderlyingCPRegTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCPRegType *) x));
}
static void *_p_FIX__RawDataTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RawData *) x));
}
static void *_p_FIX__MarketIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MarketID *) x));
}
static void *_p_FIX__SettlDate2To_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlDate2 *) x));
}
static void *_p_FIX__DlvyInstTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DlvyInst *) x));
}
static void *_p_FIX__DeskIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DeskID *) x));
}
static void *_p_FIX__NewsRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NewsRefID *) x));
}
static void *_p_FIX__CashDistribCurrTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CashDistribCurr *) x));
}
static void *_p_FIX__MarketSegmentIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MarketSegmentID *) x));
}
static void *_p_FIX__LegStipulationValueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegStipulationValue *) x));
}
static void *_p_FIX__AgreementIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementID *) x));
}
static void *_p_FIX__StipulationValueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StipulationValue *) x));
}
static void *_p_FIX__MDMktTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MDMkt *) x));
}
static void *_p_FIX__DerivativeMaturityDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeMaturityDate *) x));
}
static void *_p_FIX__UnderlyingLegMaturityDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegMaturityDate *) x));
}
static void *_p_FIX__QuantityDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuantityDate *) x));
}
static void *_p_FIX__MaturityDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityDate *) x));
}
static void *_p_FIX__LegMaturityDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegMaturityDate *) x));
}
static void *_p_FIX__UnderlyingMaturityDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityDate *) x));
}
static void *_p_FIX__OrdStatusReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrdStatusReqID *) x));
}
static void *_p_FIX__QuoteStatusReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteStatusReqID *) x));
}
static void *_p_FIX__MassStatusReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MassStatusReqID *) x));
}
static void *_p_FIX__TradSesReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradSesReqID *) x));
}
static void *_p_FIX__PosReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PosReqID *) x));
}
static void *_p_FIX__SecurityStatusReqIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityStatusReqID *) x));
}
static void *_p_FIX__StandInstDbNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StandInstDbName *) x));
}
static void *_p_FIX__DerivativeMaturityTimeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeMaturityTime *) x));
}
static void *_p_FIX__LegMaturityTimeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegMaturityTime *) x));
}
static void *_p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegMaturityTime *) x));
}
static void *_p_FIX__UnderlyingMaturityTimeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityTime *) x));
}
static void *_p_FIX__MaturityTimeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityTime *) x));
}
static void *_p_FIX__DesignationTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::Designation *) x));
}
static void *_p_FIX__ExDestinationTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExDestination *) x));
}
static void *_p_FIX__ResponseDestinationTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ResponseDestination *) x));
}
static void *_p_FIX__LegInterestAccrualDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegInterestAccrualDate *) x));
}
static void *_p_FIX__InterestAccrualDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::InterestAccrualDate *) x));
}
static void *_p_FIX__CardIssNoTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CardIssNo *) x));
}
static void *_p_FIX__LegBenchmarkCurveNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegBenchmarkCurveName *) x));
}
static void *_p_FIX__BenchmarkCurveNameTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BenchmarkCurveName *) x));
}
static void *_p_FIX__DerivativeEventDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeEventDate *) x));
}
static void *_p_FIX__CouponPaymentDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CouponPaymentDate *) x));
}
static void *_p_FIX__UnderlyingCouponPaymentDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingCouponPaymentDate *) x));
}
static void *_p_FIX__PaymentDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PaymentDate *) x));
}
static void *_p_FIX__UnderlyingSettlementDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSettlementDate *) x));
}
static void *_p_FIX__EventDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EventDate *) x));
}
static void *_p_FIX__AgreementDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::AgreementDate *) x));
}
static void *_p_FIX__LegCouponPaymentDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegCouponPaymentDate *) x));
}
static void *_p_FIX__MatchTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MatchType *) x));
}
static void *_p_FIX__CorporateActionTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CorporateAction *) x));
}
static void *_p_FIX__EmailThreadIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EmailThreadID *) x));
}
static void *_p_FIX__SettlLocationTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlLocation *) x));
}
static void *_p_FIX__MiscFeeCurrTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MiscFeeCurr *) x));
}
static void *_p_FIX__SettlTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlType *) x));
}
static void *_p_FIX__RegistDetlsTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RegistDetls *) x));
}
static void *_p_FIX__TZTransactTimeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TZTransactTime *) x));
}
static void *_p_FIX__ContraLegRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ContraLegRefID *) x));
}
static void *_p_FIX__TradeLegRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::TradeLegRefID *) x));
}
static void *_p_FIX__LegRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegRefID *) x));
}
static void *_p_FIX__SettlObligRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlObligRefID *) x));
}
static void *_p_FIX__ContractSettlMonthTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ContractSettlMonth *) x));
}
static void *_p_FIX__LegContractSettlMonthTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegContractSettlMonth *) x));
}
static void *_p_FIX__BookingRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BookingRefID *) x));
}
static void *_p_FIX__DerivativeContractSettlMonthTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeContractSettlMonth *) x));
}
static void *_p_FIX__SecureDataTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecureData *) x));
}
static void *_p_FIX__InstrAttribValueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::InstrAttribValue *) x));
}
static void *_p_FIX__NestedInstrAttribValueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::NestedInstrAttribValue *) x));
}
static void *_p_FIX__DerivativeInstrAttribValueTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeInstrAttribValue *) x));
}
static void *_p_FIX__UnderlyingSecurityExchangeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingSecurityExchange *) x));
}
static void *_p_FIX__LegSecurityExchangeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegSecurityExchange *) x));
}
static void *_p_FIX__SecurityExchangeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SecurityExchange *) x));
}
static void *_p_FIX__UnderlyingLegSecurityExchangeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegSecurityExchange *) x));
}
static void *_p_FIX__DerivativeSecurityExchangeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeSecurityExchange *) x));
}
static void *_p_FIX__RestructuringTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RestructuringType *) x));
}
static void *_p_FIX__UnderlyingRestructuringTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingRestructuringType *) x));
}
static void *_p_FIX__DateOfBirthTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DateOfBirth *) x));
}
static void *_p_FIX__ExpireDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ExpireDate *) x));
}
static void *_p_FIX__BasisFeatureDateTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::BasisFeatureDate *) x));
}
static void *_p_FIX__CollRespIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::CollRespID *) x));
}
static void *_p_FIX__RptSysTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RptSys *) x));
}
static void *_p_FIX__QuoteRespIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::QuoteRespID *) x));
}
static void *_p_FIX__ProductComplexTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ProductComplex *) x));
}
static void *_p_FIX__DerivativeProductComplexTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeProductComplex *) x));
}
static void *_p_FIX__SettlObligIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::SettlObligID *) x));
}
static void *_p_FIX__RegistIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::RegistID *) x));
}
static void *_p_FIX__MiscFeeTypeTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MiscFeeType *) x));
}
static void *_p_FIX__LegMaturityMonthYearTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::LegMaturityMonthYear *) x));
}
static void *_p_FIX__StartMaturityMonthYearTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::StartMaturityMonthYear *) x));
}
static void *_p_FIX__MaturityMonthYearTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::MaturityMonthYear *) x));
}
static void *_p_FIX__DerivativeMaturityMonthYearTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::DerivativeMaturityMonthYear *) x));
}
static void *_p_FIX__UnderlyingMaturityMonthYearTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingMaturityMonthYear *) x));
}
static void *_p_FIX__EndMaturityMonthYearTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::EndMaturityMonthYear *) x));
}
static void *_p_FIX__UnderlyingLegMaturityMonthYearTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::UnderlyingLegMaturityMonthYear *) x));
}
static void *_p_FIX__OrigPosReqRefIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::OrigPosReqRefID *) x));
}
static void *_p_FIX__PosMaintRptIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::PosMaintRptID *) x));
}
static void *_p_FIX__ContIntRptIDTo_p_FIX__StringField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::StringField *)  ((FIX::ContIntRptID *) x));
}
static void *_p_FIX__SynchronizedApplicationTo_p_FIX__Application(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Application *)  ((FIX::SynchronizedApplication *) x));
}
static void *_p_FIX__NullApplicationTo_p_FIX__Application(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Application *)  ((FIX::NullApplication *) x));
}
static void *_p_FIX__SocketSendFailedTo_p_FIX__SocketException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketSendFailed *) x));
}
static void *_p_FIX__SocketRecvFailedTo_p_FIX__SocketException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketRecvFailed *) x));
}
static void *_p_FIX__SocketCloseFailedTo_p_FIX__SocketException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::SocketException *)  ((FIX::SocketCloseFailed *) x));
}
static void *_p_FIX__RequiredTagMissingTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RequiredTagMissing *) x));
}
static void *_p_FIX__SocketSendFailedTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketSendFailed *) x));
}
static void *_p_FIX__SocketRecvFailedTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketRecvFailed *) x));
}
static void *_p_FIX__InvalidTagNumberTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidTagNumber *) x));
}
static void *_p_FIX__RejectLogonTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RejectLogon *) x));
}
static void *_p_FIX__IncorrectDataFormatTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectDataFormat *) x));
}
static void *_p_FIX__TagNotDefinedForMessageTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::TagNotDefinedForMessage *) x));
}
static void *_p_FIX__InvalidMessageTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidMessage *) x));
}
static void *_p_FIX__RuntimeErrorTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RuntimeError *) x));
}
static void *_p_FIX__MessageParseErrorTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::MessageParseError *) x));
}
static void *_p_FIX__DuplicateFieldNumberTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::DuplicateFieldNumber *) x));
}
static void *_p_FIX__DoNotSendTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::DoNotSend *) x));
}
static void *_p_FIX__FieldNotFoundTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::FieldNotFound *) x));
}
static void *_p_FIX__DataDictionaryNotFoundTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::DataDictionaryNotFound *) x));
}
static void *_p_FIX__SessionNotFoundTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::SessionNotFound *) x));
}
static void *_p_FIX__IOExceptionTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::IOException *) x));
}
static void *_p_FIX__SocketExceptionTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::SocketException *) x));
}
static void *_p_FIX__ConfigErrorTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::ConfigError *) x));
}
static void *_p_FIX__InvalidMessageTypeTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::InvalidMessageType *) x));
}
static void *_p_FIX__UnsupportedMessageTypeTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::UnsupportedMessageType *) x));
}
static void *_p_FIX__UnsupportedVersionTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::UnsupportedVersion *) x));
}
static void *_p_FIX__IncorrectTagValueTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectTagValue *) x));
}
static void *_p_FIX__NoTagValueTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::NoTagValue *) x));
}
static void *_p_FIX__TagOutOfOrderTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::TagOutOfOrder *) x));
}
static void *_p_FIX__RepeatedTagTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RepeatedTag *) x));
}
static void *_p_FIX__SocketCloseFailedTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *) (FIX::SocketException *) ((FIX::SocketCloseFailed *) x));
}
static void *_p_FIX__FieldConvertErrorTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::FieldConvertError *) x));
}
static void *_p_FIX__IncorrectMessageStructureTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::IncorrectMessageStructure *) x));
}
static void *_p_FIX__RepeatingGroupCountMismatchTo_p_FIX__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::Exception *)  ((FIX::RepeatingGroupCountMismatch *) x));
}
static void *_p_FIX__NoNewsRefIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNewsRefIDs *) x));
}
static void *_p_FIX__NoPositionsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoPositions *) x));
}
static void *_p_FIX__MaxPriceLevelsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MaxPriceLevels *) x));
}
static void *_p_FIX__NoMiscFeesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMiscFees *) x));
}
static void *_p_FIX__ClearingInstructionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ClearingInstruction *) x));
}
static void *_p_FIX__NoComplexEventTimesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoComplexEventTimes *) x));
}
static void *_p_FIX__RepurchaseTermTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RepurchaseTerm *) x));
}
static void *_p_FIX__LegRepurchaseTermTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegRepurchaseTerm *) x));
}
static void *_p_FIX__UnderlyingRepurchaseTermTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingRepurchaseTerm *) x));
}
static void *_p_FIX__MDSecSizeTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDSecSizeType *) x));
}
static void *_p_FIX__RptSeqTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RptSeq *) x));
}
static void *_p_FIX__NumBiddersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NumBidders *) x));
}
static void *_p_FIX__MultilegModelTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MultilegModel *) x));
}
static void *_p_FIX__MDPriceLevelTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDPriceLevel *) x));
}
static void *_p_FIX__QuoteResponseLevelTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteResponseLevel *) x));
}
static void *_p_FIX__ComplexEventConditionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventCondition *) x));
}
static void *_p_FIX__OptPayoutTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::OptPayoutType *) x));
}
static void *_p_FIX__SideValueIndTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SideValueInd *) x));
}
static void *_p_FIX__NoContAmtsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoContAmts *) x));
}
static void *_p_FIX__ContractMultiplierUnitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ContractMultiplierUnit *) x));
}
static void *_p_FIX__LegContractMultiplierUnitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegContractMultiplierUnit *) x));
}
static void *_p_FIX__DerivativeContractMultiplierUnitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeContractMultiplierUnit *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierUnitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingContractMultiplierUnit *) x));
}
static void *_p_FIX__ApplEndSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplEndSeqNum *) x));
}
static void *_p_FIX__RefApplLastSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RefApplLastSeqNum *) x));
}
static void *_p_FIX__ApplLastSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplLastSeqNum *) x));
}
static void *_p_FIX__RefSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RefSeqNum *) x));
}
static void *_p_FIX__ApplSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplSeqNum *) x));
}
static void *_p_FIX__NextExpectedMsgSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NextExpectedMsgSeqNum *) x));
}
static void *_p_FIX__ApplNewSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplNewSeqNum *) x));
}
static void *_p_FIX__MsgSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MsgSeqNum *) x));
}
static void *_p_FIX__ApplBegSeqNumTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplBegSeqNum *) x));
}
static void *_p_FIX__NoExecInstRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoExecInstRules *) x));
}
static void *_p_FIX__TotNoQuoteEntriesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoQuoteEntries *) x));
}
static void *_p_FIX__NoMDEntriesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMDEntries *) x));
}
static void *_p_FIX__TotQuoteEntriesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotQuoteEntries *) x));
}
static void *_p_FIX__NoQuoteEntriesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoQuoteEntries *) x));
}
static void *_p_FIX__HopRefIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::HopRefID *) x));
}
static void *_p_FIX__SessionRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SessionRejectReason *) x));
}
static void *_p_FIX__ListRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ListRejectReason *) x));
}
static void *_p_FIX__MassActionRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionRejectReason *) x));
}
static void *_p_FIX__ConfirmRejReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmRejReason *) x));
}
static void *_p_FIX__CxlRejReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CxlRejReason *) x));
}
static void *_p_FIX__StreamAsgnRejReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnRejReason *) x));
}
static void *_p_FIX__QuoteEntryRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteEntryRejectReason *) x));
}
static void *_p_FIX__ExecRestatementReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ExecRestatementReason *) x));
}
static void *_p_FIX__OrdRejReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::OrdRejReason *) x));
}
static void *_p_FIX__TradeReportRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradeReportRejectReason *) x));
}
static void *_p_FIX__QuoteRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRejectReason *) x));
}
static void *_p_FIX__CollAsgnReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnReason *) x));
}
static void *_p_FIX__MassCancelRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MassCancelRejectReason *) x));
}
static void *_p_FIX__TradSesStatusRejReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesStatusRejReason *) x));
}
static void *_p_FIX__QuoteRequestRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRequestRejectReason *) x));
}
static void *_p_FIX__CollAsgnRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnRejectReason *) x));
}
static void *_p_FIX__NoContraBrokersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoContraBrokers *) x));
}
static void *_p_FIX__RefOrdIDReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RefOrdIDReason *) x));
}
static void *_p_FIX__BusinessRejectReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::BusinessRejectReason *) x));
}
static void *_p_FIX__ShortSaleReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ShortSaleReason *) x));
}
static void *_p_FIX__AllocCancReplaceReasonTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocCancReplaceReason *) x));
}
static void *_p_FIX__SettlementCycleNoTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SettlementCycleNo *) x));
}
static void *_p_FIX__NoTrdRegTimestampsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTrdRegTimestamps *) x));
}
static void *_p_FIX__NoAffectedOrdersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoAffectedOrders *) x));
}
static void *_p_FIX__TotalAffectedOrdersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotalAffectedOrders *) x));
}
static void *_p_FIX__NoNotAffectedOrdersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNotAffectedOrders *) x));
}
static void *_p_FIX__NumberOfOrdersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NumberOfOrders *) x));
}
static void *_p_FIX__TotNoOrdersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoOrders *) x));
}
static void *_p_FIX__NoOrdersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoOrders *) x));
}
static void *_p_FIX__NoApplIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoApplIDs *) x));
}
static void *_p_FIX__ApplQueueResolutionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueResolution *) x));
}
static void *_p_FIX__AvgPrxPrecisionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AvgPrxPrecision *) x));
}
static void *_p_FIX__AvgPxPrecisionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AvgPxPrecision *) x));
}
static void *_p_FIX__AdjustmentTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Adjustment *) x));
}
static void *_p_FIX__MiscFeeBasisTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MiscFeeBasis *) x));
}
static void *_p_FIX__RegistRejReasonCodeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RegistRejReasonCode *) x));
}
static void *_p_FIX__ListStatusTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ListStatusType *) x));
}
static void *_p_FIX__NoQuoteSetsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoQuoteSets *) x));
}
static void *_p_FIX__ExpTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ExpType *) x));
}
static void *_p_FIX__EncodedIssuerLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedIssuerLen *) x));
}
static void *_p_FIX__EncodedLegIssuerLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedLegIssuerLen *) x));
}
static void *_p_FIX__EncodedUnderlyingIssuerLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedUnderlyingIssuerLen *) x));
}
static void *_p_FIX__DerivativeEncodedIssuerLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeEncodedIssuerLen *) x));
}
static void *_p_FIX__DeliveryFormTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DeliveryForm *) x));
}
static void *_p_FIX__PegLimitTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PegLimitType *) x));
}
static void *_p_FIX__DiscretionLimitTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionLimitType *) x));
}
static void *_p_FIX__SecondaryPriceLimitTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecondaryPriceLimitType *) x));
}
static void *_p_FIX__PriceLimitTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PriceLimitType *) x));
}
static void *_p_FIX__LegProductTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegProduct *) x));
}
static void *_p_FIX__NoTradingSessionsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTradingSessions *) x));
}
static void *_p_FIX__NoCapacitiesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoCapacities *) x));
}
static void *_p_FIX__DerivativeProductTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeProduct *) x));
}
static void *_p_FIX__UnderlyingProductTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingProduct *) x));
}
static void *_p_FIX__ProductTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Product *) x));
}
static void *_p_FIX__IncTaxIndTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::IncTaxInd *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingSettlPriceType *) x));
}
static void *_p_FIX__PegPriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PegPriceType *) x));
}
static void *_p_FIX__PriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PriceType *) x));
}
static void *_p_FIX__YieldRedemptionPriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::YieldRedemptionPriceType *) x));
}
static void *_p_FIX__QuotePriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuotePriceType *) x));
}
static void *_p_FIX__LegBenchmarkPriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegBenchmarkPriceType *) x));
}
static void *_p_FIX__SettlPriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SettlPriceType *) x));
}
static void *_p_FIX__TrdRegTimestampTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TrdRegTimestampType *) x));
}
static void *_p_FIX__SideTrdRegTimestampTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SideTrdRegTimestampType *) x));
}
static void *_p_FIX__LegPriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegPriceType *) x));
}
static void *_p_FIX__BenchmarkPriceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::BenchmarkPriceType *) x));
}
static void *_p_FIX__RateSourceTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RateSourceType *) x));
}
static void *_p_FIX__MassActionTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionType *) x));
}
static void *_p_FIX__TerminationTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TerminationType *) x));
}
static void *_p_FIX__NoSecurityAltIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingSecurityAltIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingSecurityAltID *) x));
}
static void *_p_FIX__NoLegSecurityAltIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoLegSecurityAltID *) x));
}
static void *_p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeSecurityAltID *) x));
}
static void *_p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingLegSecurityAltID *) x));
}
static void *_p_FIX__NoAsgnReqsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoAsgnReqs *) x));
}
static void *_p_FIX__NoMatchRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMatchRules *) x));
}
static void *_p_FIX__SecurityRequestTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityRequestType *) x));
}
static void *_p_FIX__TradeRequestTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradeRequestType *) x));
}
static void *_p_FIX__UserRequestTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UserRequestType *) x));
}
static void *_p_FIX__NetworkRequestTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NetworkRequestType *) x));
}
static void *_p_FIX__SecurityListTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityListType *) x));
}
static void *_p_FIX__QuoteRequestTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRequestType *) x));
}
static void *_p_FIX__SecurityListRequestTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityListRequestType *) x));
}
static void *_p_FIX__HeartBtIntTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::HeartBtInt *) x));
}
static void *_p_FIX__StatsTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StatsType *) x));
}
static void *_p_FIX__AllocSettlInstTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocSettlInstType *) x));
}
static void *_p_FIX__LegPutOrCallTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegPutOrCall *) x));
}
static void *_p_FIX__UnderlyingLegPutOrCallTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingLegPutOrCall *) x));
}
static void *_p_FIX__DerivativePutOrCallTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativePutOrCall *) x));
}
static void *_p_FIX__PutOrCallTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PutOrCall *) x));
}
static void *_p_FIX__UnderlyingPutOrCallTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingPutOrCall *) x));
}
static void *_p_FIX__ComplexEventPriceTimeTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventPriceTimeType *) x));
}
static void *_p_FIX__LiquidityIndTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LiquidityIndType *) x));
}
static void *_p_FIX__ContingencyTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ContingencyType *) x));
}
static void *_p_FIX__TradeAllocIndicatorTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradeAllocIndicator *) x));
}
static void *_p_FIX__TradePublishIndicatorTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradePublishIndicator *) x));
}
static void *_p_FIX__ImpliedMarketIndicatorTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ImpliedMarketIndicator *) x));
}
static void *_p_FIX__AvgPxIndicatorTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AvgPxIndicator *) x));
}
static void *_p_FIX__TrdRptStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TrdRptStatus *) x));
}
static void *_p_FIX__UserStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UserStatus *) x));
}
static void *_p_FIX__ListOrderStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ListOrderStatus *) x));
}
static void *_p_FIX__TradeRequestStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradeRequestStatus *) x));
}
static void *_p_FIX__SessionStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SessionStatus *) x));
}
static void *_p_FIX__ExerciseStyleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ExerciseStyle *) x));
}
static void *_p_FIX__StrikeExerciseStyleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StrikeExerciseStyle *) x));
}
static void *_p_FIX__CollStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollStatus *) x));
}
static void *_p_FIX__LegExerciseStyleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegExerciseStyle *) x));
}
static void *_p_FIX__PosMaintStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosMaintStatus *) x));
}
static void *_p_FIX__PriorityIndicatorTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PriorityIndicator *) x));
}
static void *_p_FIX__UnderlyingExerciseStyleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingExerciseStyle *) x));
}
static void *_p_FIX__CustOrderCapacityTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CustOrderCapacity *) x));
}
static void *_p_FIX__OrigCustOrderCapacityTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::OrigCustOrderCapacity *) x));
}
static void *_p_FIX__NoComplexEventDatesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoComplexEventDates *) x));
}
static void *_p_FIX__ConfirmStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmStatus *) x));
}
static void *_p_FIX__QuoteStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteStatus *) x));
}
static void *_p_FIX__QuoteEntryStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteEntryStatus *) x));
}
static void *_p_FIX__CollInquiryStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollInquiryStatus *) x));
}
static void *_p_FIX__TradSesStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesStatus *) x));
}
static void *_p_FIX__QuoteAckStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteAckStatus *) x));
}
static void *_p_FIX__AffirmStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AffirmStatus *) x));
}
static void *_p_FIX__PosQtyStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosQtyStatus *) x));
}
static void *_p_FIX__AllocTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocType *) x));
}
static void *_p_FIX__IndividualAllocTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::IndividualAllocType *) x));
}
static void *_p_FIX__NoSettlInstTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlInst *) x));
}
static void *_p_FIX__SecurityTradingStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityTradingStatus *) x));
}
static void *_p_FIX__AllocStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocStatus *) x));
}
static void *_p_FIX__PosReqStatusTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosReqStatus *) x));
}
static void *_p_FIX__ListSeqNoTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ListSeqNo *) x));
}
static void *_p_FIX__MaxMessageSizeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MaxMessageSize *) x));
}
static void *_p_FIX__MarketDepthTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MarketDepth *) x));
}
static void *_p_FIX__ApplResponseErrorTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplResponseError *) x));
}
static void *_p_FIX__CollApplTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollApplType *) x));
}
static void *_p_FIX__GTBookingInstTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::GTBookingInst *) x));
}
static void *_p_FIX__NumTicketsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NumTickets *) x));
}
static void *_p_FIX__LegSwapTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegSwapType *) x));
}
static void *_p_FIX__OrderDelayTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::OrderDelay *) x));
}
static void *_p_FIX__NoTradesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTrades *) x));
}
static void *_p_FIX__SecurityXMLLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityXMLLen *) x));
}
static void *_p_FIX__DerivativeSecurityXMLLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeSecurityXMLLen *) x));
}
static void *_p_FIX__MaturityMonthYearFormatTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MaturityMonthYearFormat *) x));
}
static void *_p_FIX__QuoteCancelTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteCancelType *) x));
}
static void *_p_FIX__ModelTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ModelType *) x));
}
static void *_p_FIX__NoHopsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoHops *) x));
}
static void *_p_FIX__TradeReportTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradeReportType *) x));
}
static void *_p_FIX__ResponseTransportTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ResponseTransportType *) x));
}
static void *_p_FIX__AllocReportTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocReportType *) x));
}
static void *_p_FIX__ApplReportTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplReportType *) x));
}
static void *_p_FIX__MultiLegRptTypeReqTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MultiLegRptTypeReq *) x));
}
static void *_p_FIX__CrossTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CrossType *) x));
}
static void *_p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingFlowScheduleType *) x));
}
static void *_p_FIX__FlowScheduleTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::FlowScheduleType *) x));
}
static void *_p_FIX__LegFlowScheduleTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegFlowScheduleType *) x));
}
static void *_p_FIX__DerivativeFlowScheduleTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeFlowScheduleType *) x));
}
static void *_p_FIX__TickRuleTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TickRuleType *) x));
}
static void *_p_FIX__NoRateSourcesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoRateSources *) x));
}
static void *_p_FIX__InstrumentPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::InstrumentPartyRole *) x));
}
static void *_p_FIX__Nested4PartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Nested4PartyRole *) x));
}
static void *_p_FIX__NestedPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NestedPartyRole *) x));
}
static void *_p_FIX__Nested3PartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Nested3PartyRole *) x));
}
static void *_p_FIX__PartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PartyRole *) x));
}
static void *_p_FIX__DerivativeInstrumentPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeInstrumentPartyRole *) x));
}
static void *_p_FIX__SettlPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SettlPartyRole *) x));
}
static void *_p_FIX__TrdRepPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TrdRepPartyRole *) x));
}
static void *_p_FIX__RootPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RootPartyRole *) x));
}
static void *_p_FIX__UndlyInstrumentPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UndlyInstrumentPartyRole *) x));
}
static void *_p_FIX__Nested2PartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Nested2PartyRole *) x));
}
static void *_p_FIX__TargetPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TargetPartyRole *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartyRoleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingInstrumentPartyRole *) x));
}
static void *_p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedUnderlyingSecurityDescLen *) x));
}
static void *_p_FIX__EncodedLegSecurityDescLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedLegSecurityDescLen *) x));
}
static void *_p_FIX__DerivativeEncodedSecurityDescLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeEncodedSecurityDescLen *) x));
}
static void *_p_FIX__EncodedMktSegmDescLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedMktSegmDescLen *) x));
}
static void *_p_FIX__EncodedSecurityListDescLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedSecurityListDescLen *) x));
}
static void *_p_FIX__EncodedSecurityDescLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedSecurityDescLen *) x));
}
static void *_p_FIX__SettlObligModeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SettlObligMode *) x));
}
static void *_p_FIX__LegNumberTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegNumber *) x));
}
static void *_p_FIX__StatusValueTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StatusValue *) x));
}
static void *_p_FIX__SideQtyTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SideQty *) x));
}
static void *_p_FIX__SideLiquidityIndTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SideLiquidityInd *) x));
}
static void *_p_FIX__LastLiquidityIndTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LastLiquidityInd *) x));
}
static void *_p_FIX__FillLiquidityIndTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::FillLiquidityInd *) x));
}
static void *_p_FIX__NoCollInquiryQualifierTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoCollInquiryQualifier *) x));
}
static void *_p_FIX__CollInquiryQualifierTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollInquiryQualifier *) x));
}
static void *_p_FIX__StandInstDbTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StandInstDbType *) x));
}
static void *_p_FIX__NoMarketSegmentsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMarketSegments *) x));
}
static void *_p_FIX__TargetStrategyTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TargetStrategy *) x));
}
static void *_p_FIX__NoNested2PartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested2PartySubIDs *) x));
}
static void *_p_FIX__NoPartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartySubIDs *) x));
}
static void *_p_FIX__NoInstrumentPartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeInstrumentPartySubIDs *) x));
}
static void *_p_FIX__NoSettlPartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlPartySubIDs *) x));
}
static void *_p_FIX__NoNested3PartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested3PartySubIDs *) x));
}
static void *_p_FIX__NoNested4PartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested4PartySubIDs *) x));
}
static void *_p_FIX__NoNestedPartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNestedPartySubIDs *) x));
}
static void *_p_FIX__NoRootPartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoRootPartySubIDs *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoUndlyInstrumentPartySubIDs *) x));
}
static void *_p_FIX__DiscretionMoveTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionMoveType *) x));
}
static void *_p_FIX__PegMoveTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PegMoveType *) x));
}
static void *_p_FIX__NoPosAmtTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoPosAmt *) x));
}
static void *_p_FIX__AllocNoOrdersTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocNoOrdersType *) x));
}
static void *_p_FIX__ListNoOrdsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ListNoOrds *) x));
}
static void *_p_FIX__NoSideTrdRegTSTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSideTrdRegTS *) x));
}
static void *_p_FIX__TotNoFillsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoFills *) x));
}
static void *_p_FIX__NoFillsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoFills *) x));
}
static void *_p_FIX__EncodedListExecInstLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedListExecInstLen *) x));
}
static void *_p_FIX__EncodedHeadlineLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedHeadlineLen *) x));
}
static void *_p_FIX__SellerDaysTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SellerDays *) x));
}
static void *_p_FIX__UnderlyingPriceDeterminationMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingPriceDeterminationMethod *) x));
}
static void *_p_FIX__PaymentMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PaymentMethod *) x));
}
static void *_p_FIX__StrikePriceDeterminationMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StrikePriceDeterminationMethod *) x));
}
static void *_p_FIX__EncryptMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptMethod *) x));
}
static void *_p_FIX__ListMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ListMethod *) x));
}
static void *_p_FIX__DistribPaymentMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DistribPaymentMethod *) x));
}
static void *_p_FIX__EncryptedPasswordMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptedPasswordMethod *) x));
}
static void *_p_FIX__DerivativeListMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeListMethod *) x));
}
static void *_p_FIX__StrikePriceBoundaryMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StrikePriceBoundaryMethod *) x));
}
static void *_p_FIX__MultilegPriceMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MultilegPriceMethod *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventPriceBoundaryMethod *) x));
}
static void *_p_FIX__AllocMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocMethod *) x));
}
static void *_p_FIX__LastMsgSeqNumProcessedTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LastMsgSeqNumProcessed *) x));
}
static void *_p_FIX__TradSesMethodTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesMethod *) x));
}
static void *_p_FIX__SettlInstReqRejCodeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SettlInstReqRejCode *) x));
}
static void *_p_FIX__AllocRejCodeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocRejCode *) x));
}
static void *_p_FIX__NoRegistDtlsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoRegistDtls *) x));
}
static void *_p_FIX__IndividualAllocRejCodeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::IndividualAllocRejCode *) x));
}
static void *_p_FIX__TotNoAllocsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoAllocs *) x));
}
static void *_p_FIX__NoLegAllocsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoLegAllocs *) x));
}
static void *_p_FIX__NoAllocsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoAllocs *) x));
}
static void *_p_FIX__NoMsgTypesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMsgTypes *) x));
}
static void *_p_FIX__MDBookTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDBookType *) x));
}
static void *_p_FIX__MDSubBookTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDSubBookType *) x));
}
static void *_p_FIX__NoInstrAttribTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoInstrAttrib *) x));
}
static void *_p_FIX__NoNestedInstrAttribTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNestedInstrAttrib *) x));
}
static void *_p_FIX__NoDerivativeInstrAttribTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeInstrAttrib *) x));
}
static void *_p_FIX__NoUnderlyingsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyings *) x));
}
static void *_p_FIX__NoOfLegUnderlyingsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoOfLegUnderlyings *) x));
}
static void *_p_FIX__NoCompIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoCompIDs *) x));
}
static void *_p_FIX__NoStrikeRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoStrikeRules *) x));
}
static void *_p_FIX__NoTimeInForceRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTimeInForceRules *) x));
}
static void *_p_FIX__NoLotTypeRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoLotTypeRules *) x));
}
static void *_p_FIX__NoOrdTypeRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoOrdTypeRules *) x));
}
static void *_p_FIX__NoExpirationTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoExpiration *) x));
}
static void *_p_FIX__NoDerivativeInstrumentPartiesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeInstrumentParties *) x));
}
static void *_p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoUndlyInstrumentParties *) x));
}
static void *_p_FIX__NoInstrumentPartiesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoInstrumentParties *) x));
}
static void *_p_FIX__EncryptedNewPasswordLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptedNewPasswordLen *) x));
}
static void *_p_FIX__EncryptedPasswordLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncryptedPasswordLen *) x));
}
static void *_p_FIX__NoRootPartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoRootPartyIDs *) x));
}
static void *_p_FIX__NoTargetPartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTargetPartyIDs *) x));
}
static void *_p_FIX__NoNested4PartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested4PartyIDs *) x));
}
static void *_p_FIX__NoNestedPartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNestedPartyIDs *) x));
}
static void *_p_FIX__NoNested2PartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested2PartyIDs *) x));
}
static void *_p_FIX__NoSettlPartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlPartyIDs *) x));
}
static void *_p_FIX__NoLegsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoLegs *) x));
}
static void *_p_FIX__NoPartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoPartyIDs *) x));
}
static void *_p_FIX__NoNested3PartyIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoNested3PartyIDs *) x));
}
static void *_p_FIX__NoStrategyParametersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoStrategyParameters *) x));
}
static void *_p_FIX__PegRoundDirectionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PegRoundDirection *) x));
}
static void *_p_FIX__DiscretionRoundDirectionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionRoundDirection *) x));
}
static void *_p_FIX__SideTrdSubTypTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SideTrdSubTyp *) x));
}
static void *_p_FIX__NoBidComponentsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoBidComponents *) x));
}
static void *_p_FIX__NoSettlObligTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlOblig *) x));
}
static void *_p_FIX__PegOffsetTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PegOffsetType *) x));
}
static void *_p_FIX__DiscretionOffsetTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionOffsetType *) x));
}
static void *_p_FIX__CustomerOrFirmTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CustomerOrFirm *) x));
}
static void *_p_FIX__TradSesModeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesMode *) x));
}
static void *_p_FIX__PegScopeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PegScope *) x));
}
static void *_p_FIX__SecurityReportIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityReportID *) x));
}
static void *_p_FIX__MDReportIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDReportID *) x));
}
static void *_p_FIX__AllocLinkTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocLinkType *) x));
}
static void *_p_FIX__NoUnderlyingAmountsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingAmounts *) x));
}
static void *_p_FIX__NoClearingInstructionsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoClearingInstructions *) x));
}
static void *_p_FIX__MDQuoteTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDQuoteType *) x));
}
static void *_p_FIX__MDUpdateTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDUpdateType *) x));
}
static void *_p_FIX__QuoteTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteType *) x));
}
static void *_p_FIX__StreamAsgnAckTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnAckType *) x));
}
static void *_p_FIX__QuoteRespTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuoteRespType *) x));
}
static void *_p_FIX__CollAsgnRespTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnRespType *) x));
}
static void *_p_FIX__NoMaturityRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMaturityRules *) x));
}
static void *_p_FIX__SideLastQtyTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SideLastQty *) x));
}
static void *_p_FIX__TotalNumPosReportsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotalNumPosReports *) x));
}
static void *_p_FIX__TotNumReportsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNumReports *) x));
}
static void *_p_FIX__TotNumAssignmentReportsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNumAssignmentReports *) x));
}
static void *_p_FIX__TotNumTradeReportsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNumTradeReports *) x));
}
static void *_p_FIX__XmlDataLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::XmlDataLen *) x));
}
static void *_p_FIX__SecureDataLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecureDataLen *) x));
}
static void *_p_FIX__CoveredOrUncoveredTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CoveredOrUncovered *) x));
}
static void *_p_FIX__LegCoveredOrUncoveredTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LegCoveredOrUncovered *) x));
}
static void *_p_FIX__NoTradingSessionRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTradingSessionRules *) x));
}
static void *_p_FIX__TradSesEventTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradSesEvent *) x));
}
static void *_p_FIX__ExpirationQtyTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ExpirationQtyType *) x));
}
static void *_p_FIX__QtyTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QtyType *) x));
}
static void *_p_FIX__QuantityTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::QuantityType *) x));
}
static void *_p_FIX__NoSettlDetailsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSettlDetails *) x));
}
static void *_p_FIX__CPProgramTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CPProgram *) x));
}
static void *_p_FIX__ApplTotalMessageCountTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplTotalMessageCount *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MaturityMonthYearIncrement *) x));
}
static void *_p_FIX__SecurityResponseTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityResponseType *) x));
}
static void *_p_FIX__ApplResponseTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplResponseType *) x));
}
static void *_p_FIX__ApplQueueDepthTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueDepth *) x));
}
static void *_p_FIX__NetworkStatusResponseTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NetworkStatusResponseType *) x));
}
static void *_p_FIX__NoComplexEventsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoComplexEvents *) x));
}
static void *_p_FIX__EventTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EventType *) x));
}
static void *_p_FIX__ComplexEventTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ComplexEventType *) x));
}
static void *_p_FIX__AllocAccountTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocAccountType *) x));
}
static void *_p_FIX__RespondentTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RespondentType *) x));
}
static void *_p_FIX__AccountTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AccountType *) x));
}
static void *_p_FIX__AdjustmentTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AdjustmentType *) x));
}
static void *_p_FIX__DerivativeEventTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeEventType *) x));
}
static void *_p_FIX__NoEventsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoEvents *) x));
}
static void *_p_FIX__NoDerivativeEventsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDerivativeEvents *) x));
}
static void *_p_FIX__UnderlyingSettlementTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingSettlementType *) x));
}
static void *_p_FIX__NoAltMDSourceTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoAltMDSource *) x));
}
static void *_p_FIX__AcctIDSourceTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AcctIDSource *) x));
}
static void *_p_FIX__OrderHandlingInstSourceTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::OrderHandlingInstSource *) x));
}
static void *_p_FIX__AllocAcctIDSourceTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocAcctIDSource *) x));
}
static void *_p_FIX__SecurityListTypeSourceTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityListTypeSource *) x));
}
static void *_p_FIX__RateSourceTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RateSource *) x));
}
static void *_p_FIX__DeskTypeSourceTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DeskTypeSource *) x));
}
static void *_p_FIX__BidTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::BidType *) x));
}
static void *_p_FIX__NoDatesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDates *) x));
}
static void *_p_FIX__StrategyParameterTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StrategyParameterType *) x));
}
static void *_p_FIX__OwnerTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::OwnerType *) x));
}
static void *_p_FIX__NoSidesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSides *) x));
}
static void *_p_FIX__DerivativeNTPositionLimitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeNTPositionLimit *) x));
}
static void *_p_FIX__MDOriginTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDOriginType *) x));
}
static void *_p_FIX__PositionLimitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PositionLimit *) x));
}
static void *_p_FIX__NTPositionLimitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NTPositionLimit *) x));
}
static void *_p_FIX__CrossPrioritizationTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CrossPrioritization *) x));
}
static void *_p_FIX__DerivativePositionLimitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativePositionLimit *) x));
}
static void *_p_FIX__TotNoRejQuotesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoRejQuotes *) x));
}
static void *_p_FIX__TotNoCxldQuotesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoCxldQuotes *) x));
}
static void *_p_FIX__AllocHandlInstTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocHandlInst *) x));
}
static void *_p_FIX__NoMDFeedTypesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMDFeedTypes *) x));
}
static void *_p_FIX__TotNoAccQuotesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoAccQuotes *) x));
}
static void *_p_FIX__NoBidDescriptorsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoBidDescriptors *) x));
}
static void *_p_FIX__NoTrdRepIndicatorsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTrdRepIndicators *) x));
}
static void *_p_FIX__NoStatsIndicatorsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoStatsIndicators *) x));
}
static void *_p_FIX__NoLegStipulationsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoLegStipulations *) x));
}
static void *_p_FIX__NoStipulationsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoStipulations *) x));
}
static void *_p_FIX__NoDistribInstsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDistribInsts *) x));
}
static void *_p_FIX__OrderDelayUnitTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::OrderDelayUnit *) x));
}
static void *_p_FIX__LiquidityNumSecuritiesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LiquidityNumSecurities *) x));
}
static void *_p_FIX__TotalNumSecuritiesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotalNumSecurities *) x));
}
static void *_p_FIX__EndSeqNoTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EndSeqNo *) x));
}
static void *_p_FIX__NoRptsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoRpts *) x));
}
static void *_p_FIX__SecurityTradingEventTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityTradingEvent *) x));
}
static void *_p_FIX__TrdSubTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TrdSubType *) x));
}
static void *_p_FIX__ProgRptReqsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ProgRptReqs *) x));
}
static void *_p_FIX__TotalNumSecurityTypesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotalNumSecurityTypes *) x));
}
static void *_p_FIX__NoMDEntryTypesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoMDEntryTypes *) x));
}
static void *_p_FIX__ProgPeriodIntervalTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ProgPeriodInterval *) x));
}
static void *_p_FIX__TotNoSecurityTypesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoSecurityTypes *) x));
}
static void *_p_FIX__NoSecurityTypesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoSecurityTypes *) x));
}
static void *_p_FIX__ContAmtTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ContAmtType *) x));
}
static void *_p_FIX__CollAsgnTransTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollAsgnTransType *) x));
}
static void *_p_FIX__TradeReportTransTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradeReportTransType *) x));
}
static void *_p_FIX__MassActionResponseTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionResponse *) x));
}
static void *_p_FIX__ConfirmTransTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmTransType *) x));
}
static void *_p_FIX__PosTransTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosTransType *) x));
}
static void *_p_FIX__BidDescriptorTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::BidDescriptorType *) x));
}
static void *_p_FIX__TaxAdvantageTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TaxAdvantageType *) x));
}
static void *_p_FIX__RootPartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RootPartySubIDType *) x));
}
static void *_p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeInstrumentPartySubIDType *) x));
}
static void *_p_FIX__Nested2PartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Nested2PartySubIDType *) x));
}
static void *_p_FIX__UndlyInstrumentPartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UndlyInstrumentPartySubIDType *) x));
}
static void *_p_FIX__UnderlyingInstrumentPartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::UnderlyingInstrumentPartySubIDType *) x));
}
static void *_p_FIX__NestedPartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NestedPartySubIDType *) x));
}
static void *_p_FIX__Nested3PartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Nested3PartySubIDType *) x));
}
static void *_p_FIX__SettlPartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SettlPartySubIDType *) x));
}
static void *_p_FIX__Nested4PartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::Nested4PartySubIDType *) x));
}
static void *_p_FIX__NoDlvyInstTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoDlvyInst *) x));
}
static void *_p_FIX__InstrumentPartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::InstrumentPartySubIDType *) x));
}
static void *_p_FIX__PartySubIDTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PartySubIDType *) x));
}
static void *_p_FIX__EncodedTextLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedTextLen *) x));
}
static void *_p_FIX__EncodedAllocTextLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedAllocTextLen *) x));
}
static void *_p_FIX__EncodedListStatusTextLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedListStatusTextLen *) x));
}
static void *_p_FIX__NoQuoteQualifiersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoQuoteQualifiers *) x));
}
static void *_p_FIX__NoIOIQualifiersTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoIOIQualifiers *) x));
}
static void *_p_FIX__MDEntryPositionNoTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MDEntryPositionNo *) x));
}
static void *_p_FIX__BeginSeqNoTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::BeginSeqNo *) x));
}
static void *_p_FIX__MassStatusReqTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MassStatusReqType *) x));
}
static void *_p_FIX__PosReqTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosReqType *) x));
}
static void *_p_FIX__AllocIntermedReqTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::AllocIntermedReqType *) x));
}
static void *_p_FIX__StreamAsgnReqTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnReqType *) x));
}
static void *_p_FIX__ApplReqTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplReqType *) x));
}
static void *_p_FIX__EncodedSubjectLenTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::EncodedSubjectLen *) x));
}
static void *_p_FIX__DeliveryTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DeliveryType *) x));
}
static void *_p_FIX__SettlDeliveryTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SettlDeliveryType *) x));
}
static void *_p_FIX__NewsCategoryTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NewsCategory *) x));
}
static void *_p_FIX__TrdTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TrdType *) x));
}
static void *_p_FIX__SecondaryTrdTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecondaryTrdType *) x));
}
static void *_p_FIX__TotNoRelatedSymTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoRelatedSym *) x));
}
static void *_p_FIX__NoRelatedSymTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoRelatedSym *) x));
}
static void *_p_FIX__ExpirationCycleTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ExpirationCycle *) x));
}
static void *_p_FIX__ApplQueueMaxTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueMax *) x));
}
static void *_p_FIX__CollActionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollAction *) x));
}
static void *_p_FIX__PosMaintActionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosMaintAction *) x));
}
static void *_p_FIX__NewsRefTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NewsRefType *) x));
}
static void *_p_FIX__ApplQueueActionTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplQueueAction *) x));
}
static void *_p_FIX__LinesOfTextTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::LinesOfText *) x));
}
static void *_p_FIX__MassActionScopeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MassActionScope *) x));
}
static void *_p_FIX__NoLinesOfTextTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoLinesOfText *) x));
}
static void *_p_FIX__DiscretionScopeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DiscretionScope *) x));
}
static void *_p_FIX__DerivativeInstrAttribTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DerivativeInstrAttribType *) x));
}
static void *_p_FIX__NestedInstrAttribTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NestedInstrAttribType *) x));
}
static void *_p_FIX__InstrAttribTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::InstrAttribType *) x));
}
static void *_p_FIX__NetGrossIndTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NetGrossInd *) x));
}
static void *_p_FIX__NoTickRulesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoTickRules *) x));
}
static void *_p_FIX__NoOfSecSizesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoOfSecSizes *) x));
}
static void *_p_FIX__StreamAsgnTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::StreamAsgnType *) x));
}
static void *_p_FIX__NoStrikesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoStrikes *) x));
}
static void *_p_FIX__TotNoStrikesTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TotNoStrikes *) x));
}
static void *_p_FIX__RefTagIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RefTagID *) x));
}
static void *_p_FIX__NoExecsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoExecs *) x));
}
static void *_p_FIX__SideMultiLegReportingTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SideMultiLegReportingType *) x));
}
static void *_p_FIX__RoutingTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RoutingType *) x));
}
static void *_p_FIX__BookingTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::BookingType *) x));
}
static void *_p_FIX__NumDaysInterestTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NumDaysInterest *) x));
}
static void *_p_FIX__SecurityRequestResultTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SecurityRequestResult *) x));
}
static void *_p_FIX__PosMaintResultTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosMaintResult *) x));
}
static void *_p_FIX__TradeRequestResultTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::TradeRequestResult *) x));
}
static void *_p_FIX__PosReqResultTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::PosReqResult *) x));
}
static void *_p_FIX__CollInquiryResultTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::CollInquiryResult *) x));
}
static void *_p_FIX__RawDataLengthTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RawDataLength *) x));
}
static void *_p_FIX__BodyLengthTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::BodyLength *) x));
}
static void *_p_FIX__SignatureLengthTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::SignatureLength *) x));
}
static void *_p_FIX__ApplExtIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ApplExtID *) x));
}
static void *_p_FIX__DefaultApplExtIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::DefaultApplExtID *) x));
}
static void *_p_FIX__RefApplExtIDTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::RefApplExtID *) x));
}
static void *_p_FIX__NoRoutingIDsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoRoutingIDs *) x));
}
static void *_p_FIX__NewSeqNoTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NewSeqNo *) x));
}
static void *_p_FIX__MaturityMonthYearIncrementUnitsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::MaturityMonthYearIncrementUnits *) x));
}
static void *_p_FIX__HaltReasonIntTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::HaltReasonInt *) x));
}
static void *_p_FIX__NoUnderlyingStipsTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::NoUnderlyingStips *) x));
}
static void *_p_FIX__ConfirmTypeTo_p_FIX__IntField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::IntField *)  ((FIX::ConfirmType *) x));
}
static void *_p_FIX__TradSesEndTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesEndTime *) x));
}
static void *_p_FIX__OrigTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OrigTime *) x));
}
static void *_p_FIX__DerivativeEventTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::DerivativeEventTime *) x));
}
static void *_p_FIX__EventTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::EventTime *) x));
}
static void *_p_FIX__OrigOrdModTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OrigOrdModTime *) x));
}
static void *_p_FIX__TradSesOpenTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesOpenTime *) x));
}
static void *_p_FIX__ExecValuationPointTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ExecValuationPoint *) x));
}
static void *_p_FIX__SideTimeInForceTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::SideTimeInForce *) x));
}
static void *_p_FIX__ComplexEventStartDateTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ComplexEventStartDate *) x));
}
static void *_p_FIX__ExpireTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ExpireTime *) x));
}
static void *_p_FIX__TransBkdTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TransBkdTime *) x));
}
static void *_p_FIX__TradSesPreCloseTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesPreCloseTime *) x));
}
static void *_p_FIX__TradSesCloseTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesCloseTime *) x));
}
static void *_p_FIX__TradSesStartTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TradSesStartTime *) x));
}
static void *_p_FIX__StrikeTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::StrikeTime *) x));
}
static void *_p_FIX__LastUpdateTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::LastUpdateTime *) x));
}
static void *_p_FIX__QuoteSetValidUntilTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::QuoteSetValidUntilTime *) x));
}
static void *_p_FIX__ValidUntilTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ValidUntilTime *) x));
}
static void *_p_FIX__RelSymTransactTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::RelSymTransactTime *) x));
}
static void *_p_FIX__SideTrdRegTimestampTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::SideTrdRegTimestamp *) x));
}
static void *_p_FIX__ContraTradeTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ContraTradeTime *) x));
}
static void *_p_FIX__TransactTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TransactTime *) x));
}
static void *_p_FIX__TrdRegTimestampTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::TrdRegTimestamp *) x));
}
static void *_p_FIX__OrigSendingTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OrigSendingTime *) x));
}
static void *_p_FIX__ComplexEventEndDateTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::ComplexEventEndDate *) x));
}
static void *_p_FIX__HopSendingTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::HopSendingTime *) x));
}
static void *_p_FIX__OnBehalfOfSendingTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::OnBehalfOfSendingTime *) x));
}
static void *_p_FIX__SendingTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::SendingTime *) x));
}
static void *_p_FIX__EffectiveTimeTo_p_FIX__UtcTimeStampField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeStampField *)  ((FIX::EffectiveTime *) x));
}
static void *_p_FIX__InViewOfCommonTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::InViewOfCommon *) x));
}
static void *_p_FIX__PrivateQuoteTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::PrivateQuote *) x));
}
static void *_p_FIX__ResetSeqNumFlagTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ResetSeqNumFlag *) x));
}
static void *_p_FIX__DueToRelatedTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::DueToRelated *) x));
}
static void *_p_FIX__AggregatedBookTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::AggregatedBook *) x));
}
static void *_p_FIX__LegalConfirmTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::LegalConfirm *) x));
}
static void *_p_FIX__ForexReqTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ForexReq *) x));
}
static void *_p_FIX__RefreshIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::RefreshIndicator *) x));
}
static void *_p_FIX__DefaultVerIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::DefaultVerIndicator *) x));
}
static void *_p_FIX__TrdRepIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::TrdRepIndicator *) x));
}
static void *_p_FIX__PublishTrdIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::PublishTrdIndicator *) x));
}
static void *_p_FIX__LateIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::LateIndicator *) x));
}
static void *_p_FIX__FlexibleIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::FlexibleIndicator *) x));
}
static void *_p_FIX__AutoAcceptIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::AutoAcceptIndicator *) x));
}
static void *_p_FIX__UnsolicitedIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::UnsolicitedIndicator *) x));
}
static void *_p_FIX__CopyMsgIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::CopyMsgIndicator *) x));
}
static void *_p_FIX__DerivFlexProductEligibilityIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::DerivFlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__TestMessageIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::TestMessageIndicator *) x));
}
static void *_p_FIX__WorkingIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::WorkingIndicator *) x));
}
static void *_p_FIX__PriorSpreadIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::PriorSpreadIndicator *) x));
}
static void *_p_FIX__ManualOrderIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ManualOrderIndicator *) x));
}
static void *_p_FIX__ReportToExchTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ReportToExch *) x));
}
static void *_p_FIX__ContraryInstructionIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ContraryInstructionIndicator *) x));
}
static void *_p_FIX__ReversalIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ReversalIndicator *) x));
}
static void *_p_FIX__FlexProductEligibilityIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::FlexProductEligibilityIndicator *) x));
}
static void *_p_FIX__AggressorIndicatorTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::AggressorIndicator *) x));
}
static void *_p_FIX__IOINaturalFlagTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::IOINaturalFlag *) x));
}
static void *_p_FIX__ExchangeForPhysicalTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ExchangeForPhysical *) x));
}
static void *_p_FIX__LastRptRequestedTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::LastRptRequested *) x));
}
static void *_p_FIX__SolicitedFlagTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::SolicitedFlag *) x));
}
static void *_p_FIX__TradedFlatSwitchTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::TradedFlatSwitch *) x));
}
static void *_p_FIX__CustDirectedOrderTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::CustDirectedOrder *) x));
}
static void *_p_FIX__LocateReqdTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::LocateReqd *) x));
}
static void *_p_FIX__NotifyBrokerOfCreditTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::NotifyBrokerOfCredit *) x));
}
static void *_p_FIX__MDImplicitDeleteTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::MDImplicitDelete *) x));
}
static void *_p_FIX__PossResendTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::PossResend *) x));
}
static void *_p_FIX__PossDupFlagTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::PossDupFlag *) x));
}
static void *_p_FIX__PreTradeAnonymityTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::PreTradeAnonymity *) x));
}
static void *_p_FIX__ReportedPxDiffTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ReportedPxDiff *) x));
}
static void *_p_FIX__ApplResendFlagTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::ApplResendFlag *) x));
}
static void *_p_FIX__PreviouslyReportedTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::PreviouslyReported *) x));
}
static void *_p_FIX__OddLotTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::OddLot *) x));
}
static void *_p_FIX__LastFragmentTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::LastFragment *) x));
}
static void *_p_FIX__GapFillFlagTo_p_FIX__BoolField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::BoolField *)  ((FIX::GapFillFlag *) x));
}
static void *_p_FIX__MDEntryTimeTo_p_FIX__UtcTimeOnlyField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::MDEntryTime *) x));
}
static void *_p_FIX__ComplexEventStartTimeTo_p_FIX__UtcTimeOnlyField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::ComplexEventStartTime *) x));
}
static void *_p_FIX__TotalVolumeTradedTimeTo_p_FIX__UtcTimeOnlyField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::TotalVolumeTradedTime *) x));
}
static void *_p_FIX__ComplexEventEndTimeTo_p_FIX__UtcTimeOnlyField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcTimeOnlyField *)  ((FIX::ComplexEventEndTime *) x));
}
static void *_p_FIX__MDEntryDateTo_p_FIX__UtcDateField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcDateField *)  ((FIX::MDEntryDate *) x));
}
static void *_p_FIX__TotalVolumeTradedDateTo_p_FIX__UtcDateField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::UtcDateField *)  ((FIX::TotalVolumeTradedDate *) x));
}
static void *_p_FIX__DerivativeUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingUnitOfMeasureQty *) x));
}
static void *_p_FIX__UnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnitOfMeasureQty *) x));
}
static void *_p_FIX__UnderlyingLastPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingLastPx *) x));
}
static void *_p_FIX__DerivativePriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativePriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegLastPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegLastPx *) x));
}
static void *_p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingPriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__PriceUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriceUnitOfMeasureQty *) x));
}
static void *_p_FIX__LegUnitOfMeasureQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegUnitOfMeasureQty *) x));
}
static void *_p_FIX__ReportedPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ReportedPx *) x));
}
static void *_p_FIX__UnderlyingCapValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCapValue *) x));
}
static void *_p_FIX__DisplayLowQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayLowQty *) x));
}
static void *_p_FIX__LegRatioQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegRatioQty *) x));
}
static void *_p_FIX__RatioQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::RatioQty *) x));
}
static void *_p_FIX__RoundingModulusTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::RoundingModulus *) x));
}
static void *_p_FIX__MDEntrySizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntrySize *) x));
}
static void *_p_FIX__ComplexEventPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ComplexEventPrice *) x));
}
static void *_p_FIX__LeavesQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LeavesQty *) x));
}
static void *_p_FIX__QuantityTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Quantity *) x));
}
static void *_p_FIX__UnderlyingAdjustedQuantityTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingAdjustedQuantity *) x));
}
static void *_p_FIX__DisplayMinIncrTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayMinIncr *) x));
}
static void *_p_FIX__TotalTakedownTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalTakedown *) x));
}
static void *_p_FIX__UnderlyingFactorTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingFactor *) x));
}
static void *_p_FIX__LegFactorTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegFactor *) x));
}
static void *_p_FIX__AccruedInterestAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AccruedInterestAmt *) x));
}
static void *_p_FIX__TotalAccruedInterestAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalAccruedInterestAmt *) x));
}
static void *_p_FIX__AllocAccruedInterestAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocAccruedInterestAmt *) x));
}
static void *_p_FIX__EndAccruedInterestAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndAccruedInterestAmt *) x));
}
static void *_p_FIX__FloorPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::FloorPrice *) x));
}
static void *_p_FIX__TriggerPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TriggerPrice *) x));
}
static void *_p_FIX__DerivativeFloorPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeFloorPrice *) x));
}
static void *_p_FIX__UnderlyingOriginalNotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingOriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__StopPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StopPx *) x));
}
static void *_p_FIX__ThresholdAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ThresholdAmount *) x));
}
static void *_p_FIX__UnderlyingCashAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCashAmount *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeMinPriceIncrementAmount *) x));
}
static void *_p_FIX__ComplexOptPayoutAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ComplexOptPayoutAmount *) x));
}
static void *_p_FIX__UnderlyingCollectAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCollectAmount *) x));
}
static void *_p_FIX__OptPayoutAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OptPayoutAmount *) x));
}
static void *_p_FIX__MinPriceIncrementAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinPriceIncrementAmount *) x));
}
static void *_p_FIX__UnderlyingDirtyPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingDirtyPrice *) x));
}
static void *_p_FIX__AvgParPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AvgParPx *) x));
}
static void *_p_FIX__ShortQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ShortQty *) x));
}
static void *_p_FIX__MinQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinQty *) x));
}
static void *_p_FIX__TriggerNewPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TriggerNewPrice *) x));
}
static void *_p_FIX__AllocAvgPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocAvgPx *) x));
}
static void *_p_FIX__PeggedRefPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PeggedRefPrice *) x));
}
static void *_p_FIX__ContraTradeQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ContraTradeQty *) x));
}
static void *_p_FIX__OrderBookingQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderBookingQty *) x));
}
static void *_p_FIX__CommissionTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Commission *) x));
}
static void *_p_FIX__DayAvgPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DayAvgPx *) x));
}
static void *_p_FIX__SharedCommissionTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SharedCommission *) x));
}
static void *_p_FIX__UnderlyingQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingQty *) x));
}
static void *_p_FIX__SpreadToBenchmarkTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SpreadToBenchmark *) x));
}
static void *_p_FIX__RepurchaseRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::RepurchaseRate *) x));
}
static void *_p_FIX__UnderlyingRepurchaseRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingRepurchaseRate *) x));
}
static void *_p_FIX__LegRepurchaseRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegRepurchaseRate *) x));
}
static void *_p_FIX__AttachmentPointTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AttachmentPoint *) x));
}
static void *_p_FIX__UnderlyingAttachmentPointTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingAttachmentPoint *) x));
}
static void *_p_FIX__DetachmentPointTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DetachmentPoint *) x));
}
static void *_p_FIX__UnderlyingDetachmentPointTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingDetachmentPoint *) x));
}
static void *_p_FIX__LegOptionRatioTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOptionRatio *) x));
}
static void *_p_FIX__MarginRatioTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MarginRatio *) x));
}
static void *_p_FIX__UnderlyingEndValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingEndValue *) x));
}
static void *_p_FIX__StrikeMultiplierTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikeMultiplier *) x));
}
static void *_p_FIX__ContractMultiplierTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ContractMultiplier *) x));
}
static void *_p_FIX__LegContractMultiplierTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegContractMultiplier *) x));
}
static void *_p_FIX__UnderlyingContractMultiplierTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingContractMultiplier *) x));
}
static void *_p_FIX__FeeMultiplierTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::FeeMultiplier *) x));
}
static void *_p_FIX__DerivativeContractMultiplierTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeContractMultiplier *) x));
}
static void *_p_FIX__DerivativeStrikeMultiplierTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeStrikeMultiplier *) x));
}
static void *_p_FIX__AllowableOneSidednessValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllowableOneSidednessValue *) x));
}
static void *_p_FIX__TimeToExpirationTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TimeToExpiration *) x));
}
static void *_p_FIX__OfferForwardPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferForwardPoints *) x));
}
static void *_p_FIX__MDEntryForwardPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntryForwardPoints *) x));
}
static void *_p_FIX__BidForwardPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidForwardPoints *) x));
}
static void *_p_FIX__OfferSwapPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferSwapPoints *) x));
}
static void *_p_FIX__BidSwapPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidSwapPoints *) x));
}
static void *_p_FIX__GrossTradeAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::GrossTradeAmt *) x));
}
static void *_p_FIX__SideGrossTradeAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SideGrossTradeAmt *) x));
}
static void *_p_FIX__LegOfferForwardPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOfferForwardPoints *) x));
}
static void *_p_FIX__LegGrossTradeAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegGrossTradeAmt *) x));
}
static void *_p_FIX__LegLastForwardPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegLastForwardPoints *) x));
}
static void *_p_FIX__SwapPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SwapPoints *) x));
}
static void *_p_FIX__LastForwardPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastForwardPoints *) x));
}
static void *_p_FIX__LegBidForwardPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegBidForwardPoints *) x));
}
static void *_p_FIX__LastSwapPointsTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastSwapPoints *) x));
}
static void *_p_FIX__UnderlyingFXRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingFXRate *) x));
}
static void *_p_FIX__UnderlyingDeliveryAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingDeliveryAmount *) x));
}
static void *_p_FIX__CapPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CapPrice *) x));
}
static void *_p_FIX__DerivativeOptPayAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeOptPayAmount *) x));
}
static void *_p_FIX__DerivativeCapPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeCapPrice *) x));
}
static void *_p_FIX__NetChgPrevDayTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::NetChgPrevDay *) x));
}
static void *_p_FIX__UnderlyingPayAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingPayAmount *) x));
}
static void *_p_FIX__OptPayAmountTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OptPayAmount *) x));
}
static void *_p_FIX__OfferPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferPx *) x));
}
static void *_p_FIX__MktOfferPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MktOfferPx *) x));
}
static void *_p_FIX__OfferYieldTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferYield *) x));
}
static void *_p_FIX__LegOfferPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOfferPx *) x));
}
static void *_p_FIX__MidPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MidPx *) x));
}
static void *_p_FIX__PegDifferenceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PegDifference *) x));
}
static void *_p_FIX__HighPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::HighPx *) x));
}
static void *_p_FIX__MiscFeeAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MiscFeeAmt *) x));
}
static void *_p_FIX__OrderAvgPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderAvgPx *) x));
}
static void *_p_FIX__LastParPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastParPx *) x));
}
static void *_p_FIX__PriceImprovementTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriceImprovement *) x));
}
static void *_p_FIX__OutsideIndexPctTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OutsideIndexPct *) x));
}
static void *_p_FIX__AllowableOneSidednessPctTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllowableOneSidednessPct *) x));
}
static void *_p_FIX__SellVolumeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SellVolume *) x));
}
static void *_p_FIX__PeggedPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PeggedPrice *) x));
}
static void *_p_FIX__PrevClosePxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PrevClosePx *) x));
}
static void *_p_FIX__RndPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::RndPx *) x));
}
static void *_p_FIX__EndStrikePxRangeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndStrikePxRange *) x));
}
static void *_p_FIX__StartStrikePxRangeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StartStrikePxRange *) x));
}
static void *_p_FIX__LastQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastQty *) x));
}
static void *_p_FIX__LegCalculatedCcyLastQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegCalculatedCcyLastQty *) x));
}
static void *_p_FIX__LegLastQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegLastQty *) x));
}
static void *_p_FIX__LastForwardPoints2To_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastForwardPoints2 *) x));
}
static void *_p_FIX__OfferForwardPoints2To_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferForwardPoints2 *) x));
}
static void *_p_FIX__UnderlyingPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingPx *) x));
}
static void *_p_FIX__BidForwardPoints2To_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidForwardPoints2 *) x));
}
static void *_p_FIX__CalculatedCcyLastQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CalculatedCcyLastQty *) x));
}
static void *_p_FIX__UnderlyingLastQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingLastQty *) x));
}
static void *_p_FIX__SecondaryDisplayQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryDisplayQty *) x));
}
static void *_p_FIX__BenchmarkPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BenchmarkPrice *) x));
}
static void *_p_FIX__LegBenchmarkPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegBenchmarkPrice *) x));
}
static void *_p_FIX__DisplayQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayQty *) x));
}
static void *_p_FIX__OrderQty2To_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderQty2 *) x));
}
static void *_p_FIX__StartTickPriceRangeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StartTickPriceRange *) x));
}
static void *_p_FIX__SpreadTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Spread *) x));
}
static void *_p_FIX__EndTickPriceRangeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndTickPriceRange *) x));
}
static void *_p_FIX__DiscretionOffsetTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DiscretionOffset *) x));
}
static void *_p_FIX__ParticipationRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ParticipationRate *) x));
}
static void *_p_FIX__LiquidityPctLowTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LiquidityPctLow *) x));
}
static void *_p_FIX__AllocQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocQty *) x));
}
static void *_p_FIX__LegAllocQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegAllocQty *) x));
}
static void *_p_FIX__FirstPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::FirstPx *) x));
}
static void *_p_FIX__MDEntrySpotRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntrySpotRate *) x));
}
static void *_p_FIX__TargetStrategyPerformanceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TargetStrategyPerformance *) x));
}
static void *_p_FIX__CashOutstandingTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CashOutstanding *) x));
}
static void *_p_FIX__UnderlyingNotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__DiscretionPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DiscretionPrice *) x));
}
static void *_p_FIX__BidSpotRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidSpotRate *) x));
}
static void *_p_FIX__YieldRedemptionPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::YieldRedemptionPrice *) x));
}
static void *_p_FIX__OfferSpotRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferSpotRate *) x));
}
static void *_p_FIX__NotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::NotionalPercentageOutstanding *) x));
}
static void *_p_FIX__LastSpotRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastSpotRate *) x));
}
static void *_p_FIX__OriginalNotionalPercentageOutstandingTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OriginalNotionalPercentageOutstanding *) x));
}
static void *_p_FIX__SettlCurrAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrAmt *) x));
}
static void *_p_FIX__AllocSettlCurrAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocSettlCurrAmt *) x));
}
static void *_p_FIX__TradeVolumeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TradeVolume *) x));
}
static void *_p_FIX__BuyVolumeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BuyVolume *) x));
}
static void *_p_FIX__UnderlyingEndPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingEndPrice *) x));
}
static void *_p_FIX__BidPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidPx *) x));
}
static void *_p_FIX__DerivativeStrikeValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeStrikeValue *) x));
}
static void *_p_FIX__StrikeValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikeValue *) x));
}
static void *_p_FIX__PosAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PosAmt *) x));
}
static void *_p_FIX__DisplayHighQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DisplayHighQty *) x));
}
static void *_p_FIX__SettlCurrFxRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrFxRate *) x));
}
static void *_p_FIX__SettlCurrOfferFxRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrOfferFxRate *) x));
}
static void *_p_FIX__SettlCurrBidFxRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlCurrBidFxRate *) x));
}
static void *_p_FIX__MidYieldTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MidYield *) x));
}
static void *_p_FIX__BidYieldTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidYield *) x));
}
static void *_p_FIX__MinTradeVolTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinTradeVol *) x));
}
static void *_p_FIX__MaxTradeVolTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxTradeVol *) x));
}
static void *_p_FIX__LegBidPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegBidPx *) x));
}
static void *_p_FIX__FillQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::FillQty *) x));
}
static void *_p_FIX__PriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Price *) x));
}
static void *_p_FIX__EndCashTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::EndCash *) x));
}
static void *_p_FIX__ConcessionTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Concession *) x));
}
static void *_p_FIX__CcyAmtTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CcyAmt *) x));
}
static void *_p_FIX__UnderlyingCouponRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCouponRate *) x));
}
static void *_p_FIX__LastSharesTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastShares *) x));
}
static void *_p_FIX__CouponRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CouponRate *) x));
}
static void *_p_FIX__LegCouponRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegCouponRate *) x));
}
static void *_p_FIX__SharesTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Shares *) x));
}
static void *_p_FIX__LegPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegPrice *) x));
}
static void *_p_FIX__AssignmentUnitTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AssignmentUnit *) x));
}
static void *_p_FIX__OutMainCntryUIndexTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OutMainCntryUIndex *) x));
}
static void *_p_FIX__LegQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegQty *) x));
}
static void *_p_FIX__MaxShowTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxShow *) x));
}
static void *_p_FIX__RoundLotTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::RoundLot *) x));
}
static void *_p_FIX__RiskFreeRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::RiskFreeRate *) x));
}
static void *_p_FIX__OrderCapacityQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderCapacityQty *) x));
}
static void *_p_FIX__ExpQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ExpQty *) x));
}
static void *_p_FIX__PctAtRiskTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PctAtRisk *) x));
}
static void *_p_FIX__RefreshQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::RefreshQty *) x));
}
static void *_p_FIX__MarginExcessTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MarginExcess *) x));
}
static void *_p_FIX__PegOffsetValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PegOffsetValue *) x));
}
static void *_p_FIX__ContAmtValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ContAmtValue *) x));
}
static void *_p_FIX__DiscretionOffsetValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DiscretionOffsetValue *) x));
}
static void *_p_FIX__TotalNetValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalNetValue *) x));
}
static void *_p_FIX__MinPriceIncrementTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinPriceIncrement *) x));
}
static void *_p_FIX__DerivativeMinPriceIncrementTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeMinPriceIncrement *) x));
}
static void *_p_FIX__TickIncrementTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TickIncrement *) x));
}
static void *_p_FIX__MatchIncrementTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MatchIncrement *) x));
}
static void *_p_FIX__StrikeIncrementTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikeIncrement *) x));
}
static void *_p_FIX__DividendYieldTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DividendYield *) x));
}
static void *_p_FIX__LegDividendYieldTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegDividendYield *) x));
}
static void *_p_FIX__MDEntryPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDEntryPx *) x));
}
static void *_p_FIX__MaxFloorTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxFloor *) x));
}
static void *_p_FIX__AllocInterestAtMaturityTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocInterestAtMaturity *) x));
}
static void *_p_FIX__InterestAtMaturityTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::InterestAtMaturity *) x));
}
static void *_p_FIX__CxlQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CxlQty *) x));
}
static void *_p_FIX__MaxPriceVariationTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaxPriceVariation *) x));
}
static void *_p_FIX__AllocSharesTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocShares *) x));
}
static void *_p_FIX__EventPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::EventPx *) x));
}
static void *_p_FIX__DerivativeEventPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeEventPx *) x));
}
static void *_p_FIX__YieldTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Yield *) x));
}
static void *_p_FIX__PriceDeltaTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriceDelta *) x));
}
static void *_p_FIX__LegVolatilityTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegVolatility *) x));
}
static void *_p_FIX__VolatilityTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Volatility *) x));
}
static void *_p_FIX__MinBidSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinBidSize *) x));
}
static void *_p_FIX__DefBidSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DefBidSize *) x));
}
static void *_p_FIX__BidSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BidSize *) x));
}
static void *_p_FIX__FillPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::FillPx *) x));
}
static void *_p_FIX__LegStrikePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegStrikePrice *) x));
}
static void *_p_FIX__DerivativeStrikePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DerivativeStrikePrice *) x));
}
static void *_p_FIX__SecondaryTradingReferencePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryTradingReferencePrice *) x));
}
static void *_p_FIX__TradingReferencePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TradingReferencePrice *) x));
}
static void *_p_FIX__StrikePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikePrice *) x));
}
static void *_p_FIX__UnderlyingStrikePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingStrikePrice *) x));
}
static void *_p_FIX__UnderlyingLegStrikePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingLegStrikePrice *) x));
}
static void *_p_FIX__Price2To_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Price2 *) x));
}
static void *_p_FIX__AvgPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AvgPx *) x));
}
static void *_p_FIX__CurrencyRatioTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CurrencyRatio *) x));
}
static void *_p_FIX__LegCurrencyRatioTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegCurrencyRatio *) x));
}
static void *_p_FIX__SettlPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SettlPrice *) x));
}
static void *_p_FIX__UnderlyingSettlPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingSettlPrice *) x));
}
static void *_p_FIX__CumQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CumQty *) x));
}
static void *_p_FIX__PriorSettlPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::PriorSettlPrice *) x));
}
static void *_p_FIX__OpenInterestTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OpenInterest *) x));
}
static void *_p_FIX__DistribPercentageTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DistribPercentage *) x));
}
static void *_p_FIX__LegOrderQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LegOrderQty *) x));
}
static void *_p_FIX__CashOrderQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CashOrderQty *) x));
}
static void *_p_FIX__DayOrderQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DayOrderQty *) x));
}
static void *_p_FIX__OrderQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderQty *) x));
}
static void *_p_FIX__AllocNetMoneyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocNetMoney *) x));
}
static void *_p_FIX__NetMoneyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::NetMoney *) x));
}
static void *_p_FIX__MaturityNetMoneyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MaturityNetMoney *) x));
}
static void *_p_FIX__LongQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LongQty *) x));
}
static void *_p_FIX__ExecPriceAdjustmentTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ExecPriceAdjustment *) x));
}
static void *_p_FIX__UnderlyingStartValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingStartValue *) x));
}
static void *_p_FIX__UnderlyingCurrentValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingCurrentValue *) x));
}
static void *_p_FIX__LastPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LastPx *) x));
}
static void *_p_FIX__MinOfferSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinOfferSize *) x));
}
static void *_p_FIX__OfferSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OfferSize *) x));
}
static void *_p_FIX__DefOfferSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DefOfferSize *) x));
}
static void *_p_FIX__FairValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::FairValue *) x));
}
static void *_p_FIX__LowPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LowPx *) x));
}
static void *_p_FIX__SideValue1To_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SideValue1 *) x));
}
static void *_p_FIX__SideValue2To_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SideValue2 *) x));
}
static void *_p_FIX__MktBidPxTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MktBidPx *) x));
}
static void *_p_FIX__LiquidityValueTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LiquidityValue *) x));
}
static void *_p_FIX__StartCashTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StartCash *) x));
}
static void *_p_FIX__WtAverageLiquidityTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::WtAverageLiquidity *) x));
}
static void *_p_FIX__TotalVolumeTradedTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TotalVolumeTraded *) x));
}
static void *_p_FIX__BasisFeaturePriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::BasisFeaturePrice *) x));
}
static void *_p_FIX__EFPTrackingErrorTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::EFPTrackingError *) x));
}
static void *_p_FIX__TriggerNewQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::TriggerNewQty *) x));
}
static void *_p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ComplexEventPriceBoundaryPrecision *) x));
}
static void *_p_FIX__StrikePriceBoundaryPrecisionTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::StrikePriceBoundaryPrecision *) x));
}
static void *_p_FIX__SecondaryLowLimitPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryLowLimitPrice *) x));
}
static void *_p_FIX__SecondaryHighLimitPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::SecondaryHighLimitPrice *) x));
}
static void *_p_FIX__HighLimitPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::HighLimitPrice *) x));
}
static void *_p_FIX__LowLimitPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LowLimitPrice *) x));
}
static void *_p_FIX__MinLotSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MinLotSize *) x));
}
static void *_p_FIX__AllocPriceTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AllocPrice *) x));
}
static void *_p_FIX__ValueOfFuturesTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::ValueOfFutures *) x));
}
static void *_p_FIX__FactorTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::Factor *) x));
}
static void *_p_FIX__DayCumQtyTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::DayCumQty *) x));
}
static void *_p_FIX__LiquidityPctHighTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::LiquidityPctHigh *) x));
}
static void *_p_FIX__CrossPercentTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::CrossPercent *) x));
}
static void *_p_FIX__OrderPercentTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::OrderPercent *) x));
}
static void *_p_FIX__UnderlyingAllocationPercentTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::UnderlyingAllocationPercent *) x));
}
static void *_p_FIX__AccruedInterestRateTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::AccruedInterestRate *) x));
}
static void *_p_FIX__MDSecSizeTo_p_FIX__DoubleField(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((FIX::DoubleField *)  ((FIX::MDSecSize *) x));
}
static swig_type_info _swigt__p_ApplVerID = {"_p_ApplVerID", "ApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Application = {"_p_Application", "Application *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BeginString = {"_p_BeginString", "BeginString *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DOMDocumentPtr = {"_p_DOMDocumentPtr", "DOMDocumentPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Data = {"_p_Data", "Data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DataDictionary = {"_p_DataDictionary", "DataDictionary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DataDictionaryProvider = {"_p_DataDictionaryProvider", "DataDictionaryProvider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Dictionaries = {"_p_Dictionaries", "Dictionaries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DoubleField = {"_p_DoubleField", "DoubleField *|QtyField *|PriceField *|PercentageField *|AmtField *|FloatField *|PriceOffsetField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AMT = {"_p_FIX__AMT", "FIX::AMT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Acceptor = {"_p_FIX__Acceptor", "FIX::Acceptor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Account = {"_p_FIX__Account", "FIX::Account *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AccountType = {"_p_FIX__AccountType", "FIX::AccountType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AccruedInterestAmt = {"_p_FIX__AccruedInterestAmt", "FIX::AccruedInterestAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AccruedInterestRate = {"_p_FIX__AccruedInterestRate", "FIX::AccruedInterestRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AcctIDSource = {"_p_FIX__AcctIDSource", "FIX::AcctIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Adjustment = {"_p_FIX__Adjustment", "FIX::Adjustment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdjustmentType = {"_p_FIX__AdjustmentType", "FIX::AdjustmentType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdvId = {"_p_FIX__AdvId", "FIX::AdvId *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdvRefID = {"_p_FIX__AdvRefID", "FIX::AdvRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdvSide = {"_p_FIX__AdvSide", "FIX::AdvSide *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AdvTransType = {"_p_FIX__AdvTransType", "FIX::AdvTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AffectedOrderID = {"_p_FIX__AffectedOrderID", "FIX::AffectedOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AffectedSecondaryOrderID = {"_p_FIX__AffectedSecondaryOrderID", "FIX::AffectedSecondaryOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AffirmStatus = {"_p_FIX__AffirmStatus", "FIX::AffirmStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AggregatedBook = {"_p_FIX__AggregatedBook", "FIX::AggregatedBook *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AggressorIndicator = {"_p_FIX__AggressorIndicator", "FIX::AggressorIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AgreementCurrency = {"_p_FIX__AgreementCurrency", "FIX::AgreementCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AgreementDate = {"_p_FIX__AgreementDate", "FIX::AgreementDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AgreementDesc = {"_p_FIX__AgreementDesc", "FIX::AgreementDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AgreementID = {"_p_FIX__AgreementID", "FIX::AgreementID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAccount = {"_p_FIX__AllocAccount", "FIX::AllocAccount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAccountType = {"_p_FIX__AllocAccountType", "FIX::AllocAccountType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAccruedInterestAmt = {"_p_FIX__AllocAccruedInterestAmt", "FIX::AllocAccruedInterestAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAcctIDSource = {"_p_FIX__AllocAcctIDSource", "FIX::AllocAcctIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocAvgPx = {"_p_FIX__AllocAvgPx", "FIX::AllocAvgPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocCancReplaceReason = {"_p_FIX__AllocCancReplaceReason", "FIX::AllocCancReplaceReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocClearingFeeIndicator = {"_p_FIX__AllocClearingFeeIndicator", "FIX::AllocClearingFeeIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocCustomerCapacity = {"_p_FIX__AllocCustomerCapacity", "FIX::AllocCustomerCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocHandlInst = {"_p_FIX__AllocHandlInst", "FIX::AllocHandlInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocID = {"_p_FIX__AllocID", "FIX::AllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocInterestAtMaturity = {"_p_FIX__AllocInterestAtMaturity", "FIX::AllocInterestAtMaturity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocIntermedReqType = {"_p_FIX__AllocIntermedReqType", "FIX::AllocIntermedReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocLinkID = {"_p_FIX__AllocLinkID", "FIX::AllocLinkID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocLinkType = {"_p_FIX__AllocLinkType", "FIX::AllocLinkType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocMethod = {"_p_FIX__AllocMethod", "FIX::AllocMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocNetMoney = {"_p_FIX__AllocNetMoney", "FIX::AllocNetMoney *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocNoOrdersType = {"_p_FIX__AllocNoOrdersType", "FIX::AllocNoOrdersType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocPositionEffect = {"_p_FIX__AllocPositionEffect", "FIX::AllocPositionEffect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocPrice = {"_p_FIX__AllocPrice", "FIX::AllocPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocQty = {"_p_FIX__AllocQty", "FIX::AllocQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocRejCode = {"_p_FIX__AllocRejCode", "FIX::AllocRejCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocReportID = {"_p_FIX__AllocReportID", "FIX::AllocReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocReportRefID = {"_p_FIX__AllocReportRefID", "FIX::AllocReportRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocReportType = {"_p_FIX__AllocReportType", "FIX::AllocReportType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocSettlCurrAmt = {"_p_FIX__AllocSettlCurrAmt", "FIX::AllocSettlCurrAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocSettlCurrency = {"_p_FIX__AllocSettlCurrency", "FIX::AllocSettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocSettlInstType = {"_p_FIX__AllocSettlInstType", "FIX::AllocSettlInstType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocShares = {"_p_FIX__AllocShares", "FIX::AllocShares *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocStatus = {"_p_FIX__AllocStatus", "FIX::AllocStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocText = {"_p_FIX__AllocText", "FIX::AllocText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocTransType = {"_p_FIX__AllocTransType", "FIX::AllocTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllocType = {"_p_FIX__AllocType", "FIX::AllocType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllowableOneSidednessCurr = {"_p_FIX__AllowableOneSidednessCurr", "FIX::AllowableOneSidednessCurr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllowableOneSidednessPct = {"_p_FIX__AllowableOneSidednessPct", "FIX::AllowableOneSidednessPct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AllowableOneSidednessValue = {"_p_FIX__AllowableOneSidednessValue", "FIX::AllowableOneSidednessValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AltMDSourceID = {"_p_FIX__AltMDSourceID", "FIX::AltMDSourceID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplBegSeqNum = {"_p_FIX__ApplBegSeqNum", "FIX::ApplBegSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplEndSeqNum = {"_p_FIX__ApplEndSeqNum", "FIX::ApplEndSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplExtID = {"_p_FIX__ApplExtID", "FIX::ApplExtID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplID = {"_p_FIX__ApplID", "FIX::ApplID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplLastSeqNum = {"_p_FIX__ApplLastSeqNum", "FIX::ApplLastSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplNewSeqNum = {"_p_FIX__ApplNewSeqNum", "FIX::ApplNewSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplQueueAction = {"_p_FIX__ApplQueueAction", "FIX::ApplQueueAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplQueueDepth = {"_p_FIX__ApplQueueDepth", "FIX::ApplQueueDepth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplQueueMax = {"_p_FIX__ApplQueueMax", "FIX::ApplQueueMax *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplQueueResolution = {"_p_FIX__ApplQueueResolution", "FIX::ApplQueueResolution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplReportID = {"_p_FIX__ApplReportID", "FIX::ApplReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplReportType = {"_p_FIX__ApplReportType", "FIX::ApplReportType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplReqID = {"_p_FIX__ApplReqID", "FIX::ApplReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplReqType = {"_p_FIX__ApplReqType", "FIX::ApplReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplResendFlag = {"_p_FIX__ApplResendFlag", "FIX::ApplResendFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplResponseError = {"_p_FIX__ApplResponseError", "FIX::ApplResponseError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplResponseID = {"_p_FIX__ApplResponseID", "FIX::ApplResponseID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplResponseType = {"_p_FIX__ApplResponseType", "FIX::ApplResponseType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplSeqNum = {"_p_FIX__ApplSeqNum", "FIX::ApplSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplTotalMessageCount = {"_p_FIX__ApplTotalMessageCount", "FIX::ApplTotalMessageCount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ApplVerID = {"_p_FIX__ApplVerID", "FIX::ApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Application = {"_p_FIX__Application", "FIX::Application *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AsOfIndicator = {"_p_FIX__AsOfIndicator", "FIX::AsOfIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AsgnRptID = {"_p_FIX__AsgnRptID", "FIX::AsgnRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AssignmentMethod = {"_p_FIX__AssignmentMethod", "FIX::AssignmentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AssignmentUnit = {"_p_FIX__AssignmentUnit", "FIX::AssignmentUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AttachmentPoint = {"_p_FIX__AttachmentPoint", "FIX::AttachmentPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AutoAcceptIndicator = {"_p_FIX__AutoAcceptIndicator", "FIX::AutoAcceptIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgParPx = {"_p_FIX__AvgParPx", "FIX::AvgParPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgPrxPrecision = {"_p_FIX__AvgPrxPrecision", "FIX::AvgPrxPrecision *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgPx = {"_p_FIX__AvgPx", "FIX::AvgPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgPxIndicator = {"_p_FIX__AvgPxIndicator", "FIX::AvgPxIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__AvgPxPrecision = {"_p_FIX__AvgPxPrecision", "FIX::AvgPxPrecision *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BOOLEAN = {"_p_FIX__BOOLEAN", "FIX::BOOLEAN *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BasisFeatureDate = {"_p_FIX__BasisFeatureDate", "FIX::BasisFeatureDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BasisFeaturePrice = {"_p_FIX__BasisFeaturePrice", "FIX::BasisFeaturePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BasisPxType = {"_p_FIX__BasisPxType", "FIX::BasisPxType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BeginSeqNo = {"_p_FIX__BeginSeqNo", "FIX::BeginSeqNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BeginString = {"_p_FIX__BeginString", "FIX::BeginString *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Benchmark = {"_p_FIX__Benchmark", "FIX::Benchmark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkCurveCurrency = {"_p_FIX__BenchmarkCurveCurrency", "FIX::BenchmarkCurveCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkCurveName = {"_p_FIX__BenchmarkCurveName", "FIX::BenchmarkCurveName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkCurvePoint = {"_p_FIX__BenchmarkCurvePoint", "FIX::BenchmarkCurvePoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkPrice = {"_p_FIX__BenchmarkPrice", "FIX::BenchmarkPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkPriceType = {"_p_FIX__BenchmarkPriceType", "FIX::BenchmarkPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkSecurityID = {"_p_FIX__BenchmarkSecurityID", "FIX::BenchmarkSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BenchmarkSecurityIDSource = {"_p_FIX__BenchmarkSecurityIDSource", "FIX::BenchmarkSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidDescriptor = {"_p_FIX__BidDescriptor", "FIX::BidDescriptor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidDescriptorType = {"_p_FIX__BidDescriptorType", "FIX::BidDescriptorType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidForwardPoints = {"_p_FIX__BidForwardPoints", "FIX::BidForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidForwardPoints2 = {"_p_FIX__BidForwardPoints2", "FIX::BidForwardPoints2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidID = {"_p_FIX__BidID", "FIX::BidID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidPx = {"_p_FIX__BidPx", "FIX::BidPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidRequestTransType = {"_p_FIX__BidRequestTransType", "FIX::BidRequestTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidSize = {"_p_FIX__BidSize", "FIX::BidSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidSpotRate = {"_p_FIX__BidSpotRate", "FIX::BidSpotRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidSwapPoints = {"_p_FIX__BidSwapPoints", "FIX::BidSwapPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidTradeType = {"_p_FIX__BidTradeType", "FIX::BidTradeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidType = {"_p_FIX__BidType", "FIX::BidType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BidYield = {"_p_FIX__BidYield", "FIX::BidYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BodyLength = {"_p_FIX__BodyLength", "FIX::BodyLength *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BookingRefID = {"_p_FIX__BookingRefID", "FIX::BookingRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BookingType = {"_p_FIX__BookingType", "FIX::BookingType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BookingUnit = {"_p_FIX__BookingUnit", "FIX::BookingUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BoolField = {"_p_FIX__BoolField", "FIX::BoolField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BrokerOfCredit = {"_p_FIX__BrokerOfCredit", "FIX::BrokerOfCredit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BusinessRejectReason = {"_p_FIX__BusinessRejectReason", "FIX::BusinessRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BusinessRejectRefID = {"_p_FIX__BusinessRejectRefID", "FIX::BusinessRejectRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__BuyVolume = {"_p_FIX__BuyVolume", "FIX::BuyVolume *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CFICode = {"_p_FIX__CFICode", "FIX::CFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CHAR = {"_p_FIX__CHAR", "FIX::CHAR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__COUNTRY = {"_p_FIX__COUNTRY", "FIX::COUNTRY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CPProgram = {"_p_FIX__CPProgram", "FIX::CPProgram *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CPRegType = {"_p_FIX__CPRegType", "FIX::CPRegType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CURRENCY = {"_p_FIX__CURRENCY", "FIX::CURRENCY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CalculatedCcyLastQty = {"_p_FIX__CalculatedCcyLastQty", "FIX::CalculatedCcyLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CancellationRights = {"_p_FIX__CancellationRights", "FIX::CancellationRights *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CapPrice = {"_p_FIX__CapPrice", "FIX::CapPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardExpDate = {"_p_FIX__CardExpDate", "FIX::CardExpDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardHolderName = {"_p_FIX__CardHolderName", "FIX::CardHolderName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardIssNo = {"_p_FIX__CardIssNo", "FIX::CardIssNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardIssNum = {"_p_FIX__CardIssNum", "FIX::CardIssNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardNumber = {"_p_FIX__CardNumber", "FIX::CardNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CardStartDate = {"_p_FIX__CardStartDate", "FIX::CardStartDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribAgentAcctName = {"_p_FIX__CashDistribAgentAcctName", "FIX::CashDistribAgentAcctName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribAgentAcctNumber = {"_p_FIX__CashDistribAgentAcctNumber", "FIX::CashDistribAgentAcctNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribAgentCode = {"_p_FIX__CashDistribAgentCode", "FIX::CashDistribAgentCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribAgentName = {"_p_FIX__CashDistribAgentName", "FIX::CashDistribAgentName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribCurr = {"_p_FIX__CashDistribCurr", "FIX::CashDistribCurr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashDistribPayRef = {"_p_FIX__CashDistribPayRef", "FIX::CashDistribPayRef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashMargin = {"_p_FIX__CashMargin", "FIX::CashMargin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashOrderQty = {"_p_FIX__CashOrderQty", "FIX::CashOrderQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashOutstanding = {"_p_FIX__CashOutstanding", "FIX::CashOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentAcctName = {"_p_FIX__CashSettlAgentAcctName", "FIX::CashSettlAgentAcctName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentAcctNum = {"_p_FIX__CashSettlAgentAcctNum", "FIX::CashSettlAgentAcctNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentCode = {"_p_FIX__CashSettlAgentCode", "FIX::CashSettlAgentCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentContactName = {"_p_FIX__CashSettlAgentContactName", "FIX::CashSettlAgentContactName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentContactPhone = {"_p_FIX__CashSettlAgentContactPhone", "FIX::CashSettlAgentContactPhone *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CashSettlAgentName = {"_p_FIX__CashSettlAgentName", "FIX::CashSettlAgentName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CcyAmt = {"_p_FIX__CcyAmt", "FIX::CcyAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CharField = {"_p_FIX__CharField", "FIX::CharField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CheckSum = {"_p_FIX__CheckSum", "FIX::CheckSum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CheckSumField = {"_p_FIX__CheckSumField", "FIX::CheckSumField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClOrdID = {"_p_FIX__ClOrdID", "FIX::ClOrdID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClOrdLinkID = {"_p_FIX__ClOrdLinkID", "FIX::ClOrdLinkID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingAccount = {"_p_FIX__ClearingAccount", "FIX::ClearingAccount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingBusinessDate = {"_p_FIX__ClearingBusinessDate", "FIX::ClearingBusinessDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingFeeIndicator = {"_p_FIX__ClearingFeeIndicator", "FIX::ClearingFeeIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingFirm = {"_p_FIX__ClearingFirm", "FIX::ClearingFirm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClearingInstruction = {"_p_FIX__ClearingInstruction", "FIX::ClearingInstruction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClientBidID = {"_p_FIX__ClientBidID", "FIX::ClientBidID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ClientID = {"_p_FIX__ClientID", "FIX::ClientID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAction = {"_p_FIX__CollAction", "FIX::CollAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollApplType = {"_p_FIX__CollApplType", "FIX::CollApplType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnID = {"_p_FIX__CollAsgnID", "FIX::CollAsgnID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnReason = {"_p_FIX__CollAsgnReason", "FIX::CollAsgnReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnRefID = {"_p_FIX__CollAsgnRefID", "FIX::CollAsgnRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnRejectReason = {"_p_FIX__CollAsgnRejectReason", "FIX::CollAsgnRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnRespType = {"_p_FIX__CollAsgnRespType", "FIX::CollAsgnRespType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollAsgnTransType = {"_p_FIX__CollAsgnTransType", "FIX::CollAsgnTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollInquiryID = {"_p_FIX__CollInquiryID", "FIX::CollInquiryID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollInquiryQualifier = {"_p_FIX__CollInquiryQualifier", "FIX::CollInquiryQualifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollInquiryResult = {"_p_FIX__CollInquiryResult", "FIX::CollInquiryResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollInquiryStatus = {"_p_FIX__CollInquiryStatus", "FIX::CollInquiryStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollReqID = {"_p_FIX__CollReqID", "FIX::CollReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollRespID = {"_p_FIX__CollRespID", "FIX::CollRespID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollRptID = {"_p_FIX__CollRptID", "FIX::CollRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CollStatus = {"_p_FIX__CollStatus", "FIX::CollStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CommCurrency = {"_p_FIX__CommCurrency", "FIX::CommCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CommType = {"_p_FIX__CommType", "FIX::CommType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Commission = {"_p_FIX__Commission", "FIX::Commission *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventCondition = {"_p_FIX__ComplexEventCondition", "FIX::ComplexEventCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventEndDate = {"_p_FIX__ComplexEventEndDate", "FIX::ComplexEventEndDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventEndTime = {"_p_FIX__ComplexEventEndTime", "FIX::ComplexEventEndTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventPrice = {"_p_FIX__ComplexEventPrice", "FIX::ComplexEventPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventPriceBoundaryMethod = {"_p_FIX__ComplexEventPriceBoundaryMethod", "FIX::ComplexEventPriceBoundaryMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventPriceBoundaryPrecision = {"_p_FIX__ComplexEventPriceBoundaryPrecision", "FIX::ComplexEventPriceBoundaryPrecision *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventPriceTimeType = {"_p_FIX__ComplexEventPriceTimeType", "FIX::ComplexEventPriceTimeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventStartDate = {"_p_FIX__ComplexEventStartDate", "FIX::ComplexEventStartDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventStartTime = {"_p_FIX__ComplexEventStartTime", "FIX::ComplexEventStartTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexEventType = {"_p_FIX__ComplexEventType", "FIX::ComplexEventType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplexOptPayoutAmount = {"_p_FIX__ComplexOptPayoutAmount", "FIX::ComplexOptPayoutAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ComplianceID = {"_p_FIX__ComplianceID", "FIX::ComplianceID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Concession = {"_p_FIX__Concession", "FIX::Concession *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfigError = {"_p_FIX__ConfigError", "FIX::ConfigError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmID = {"_p_FIX__ConfirmID", "FIX::ConfirmID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmRefID = {"_p_FIX__ConfirmRefID", "FIX::ConfirmRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmRejReason = {"_p_FIX__ConfirmRejReason", "FIX::ConfirmRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmReqID = {"_p_FIX__ConfirmReqID", "FIX::ConfirmReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmStatus = {"_p_FIX__ConfirmStatus", "FIX::ConfirmStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmTransType = {"_p_FIX__ConfirmTransType", "FIX::ConfirmTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ConfirmType = {"_p_FIX__ConfirmType", "FIX::ConfirmType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContAmtCurr = {"_p_FIX__ContAmtCurr", "FIX::ContAmtCurr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContAmtType = {"_p_FIX__ContAmtType", "FIX::ContAmtType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContAmtValue = {"_p_FIX__ContAmtValue", "FIX::ContAmtValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContIntRptID = {"_p_FIX__ContIntRptID", "FIX::ContIntRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContingencyType = {"_p_FIX__ContingencyType", "FIX::ContingencyType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraBroker = {"_p_FIX__ContraBroker", "FIX::ContraBroker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraLegRefID = {"_p_FIX__ContraLegRefID", "FIX::ContraLegRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraTradeQty = {"_p_FIX__ContraTradeQty", "FIX::ContraTradeQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraTradeTime = {"_p_FIX__ContraTradeTime", "FIX::ContraTradeTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraTrader = {"_p_FIX__ContraTrader", "FIX::ContraTrader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContractMultiplier = {"_p_FIX__ContractMultiplier", "FIX::ContractMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContractMultiplierUnit = {"_p_FIX__ContractMultiplierUnit", "FIX::ContractMultiplierUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContractSettlMonth = {"_p_FIX__ContractSettlMonth", "FIX::ContractSettlMonth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ContraryInstructionIndicator = {"_p_FIX__ContraryInstructionIndicator", "FIX::ContraryInstructionIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CopyMsgIndicator = {"_p_FIX__CopyMsgIndicator", "FIX::CopyMsgIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CorporateAction = {"_p_FIX__CorporateAction", "FIX::CorporateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Country = {"_p_FIX__Country", "FIX::Country *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CountryOfIssue = {"_p_FIX__CountryOfIssue", "FIX::CountryOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CouponPaymentDate = {"_p_FIX__CouponPaymentDate", "FIX::CouponPaymentDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CouponRate = {"_p_FIX__CouponRate", "FIX::CouponRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CoveredOrUncovered = {"_p_FIX__CoveredOrUncovered", "FIX::CoveredOrUncovered *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CreditRating = {"_p_FIX__CreditRating", "FIX::CreditRating *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CrossID = {"_p_FIX__CrossID", "FIX::CrossID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CrossPercent = {"_p_FIX__CrossPercent", "FIX::CrossPercent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CrossPrioritization = {"_p_FIX__CrossPrioritization", "FIX::CrossPrioritization *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CrossType = {"_p_FIX__CrossType", "FIX::CrossType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CstmApplVerID = {"_p_FIX__CstmApplVerID", "FIX::CstmApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CumQty = {"_p_FIX__CumQty", "FIX::CumQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Currency = {"_p_FIX__Currency", "FIX::Currency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CurrencyRatio = {"_p_FIX__CurrencyRatio", "FIX::CurrencyRatio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CustDirectedOrder = {"_p_FIX__CustDirectedOrder", "FIX::CustDirectedOrder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CustOrderCapacity = {"_p_FIX__CustOrderCapacity", "FIX::CustOrderCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CustOrderHandlingInst = {"_p_FIX__CustOrderHandlingInst", "FIX::CustOrderHandlingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CustomerOrFirm = {"_p_FIX__CustomerOrFirm", "FIX::CustomerOrFirm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CxlQty = {"_p_FIX__CxlQty", "FIX::CxlQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CxlRejReason = {"_p_FIX__CxlRejReason", "FIX::CxlRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CxlRejResponseTo = {"_p_FIX__CxlRejResponseTo", "FIX::CxlRejResponseTo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__CxlType = {"_p_FIX__CxlType", "FIX::CxlType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DATA = {"_p_FIX__DATA", "FIX::DATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DAYOFMONTH = {"_p_FIX__DAYOFMONTH", "FIX::DAYOFMONTH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DKReason = {"_p_FIX__DKReason", "FIX::DKReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DataDictionary = {"_p_FIX__DataDictionary", "FIX::DataDictionary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DataDictionaryNotFound = {"_p_FIX__DataDictionaryNotFound", "FIX::DataDictionaryNotFound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DateOfBirth = {"_p_FIX__DateOfBirth", "FIX::DateOfBirth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DatedDate = {"_p_FIX__DatedDate", "FIX::DatedDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DayAvgPx = {"_p_FIX__DayAvgPx", "FIX::DayAvgPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DayBookingInst = {"_p_FIX__DayBookingInst", "FIX::DayBookingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DayCumQty = {"_p_FIX__DayCumQty", "FIX::DayCumQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DayOrderQty = {"_p_FIX__DayOrderQty", "FIX::DayOrderQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DealingCapacity = {"_p_FIX__DealingCapacity", "FIX::DealingCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefBidSize = {"_p_FIX__DefBidSize", "FIX::DefBidSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefOfferSize = {"_p_FIX__DefOfferSize", "FIX::DefOfferSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefaultApplExtID = {"_p_FIX__DefaultApplExtID", "FIX::DefaultApplExtID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefaultApplVerID = {"_p_FIX__DefaultApplVerID", "FIX::DefaultApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefaultCstmApplVerID = {"_p_FIX__DefaultCstmApplVerID", "FIX::DefaultCstmApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DefaultVerIndicator = {"_p_FIX__DefaultVerIndicator", "FIX::DefaultVerIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeleteReason = {"_p_FIX__DeleteReason", "FIX::DeleteReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliverToCompID = {"_p_FIX__DeliverToCompID", "FIX::DeliverToCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliverToLocationID = {"_p_FIX__DeliverToLocationID", "FIX::DeliverToLocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliverToSubID = {"_p_FIX__DeliverToSubID", "FIX::DeliverToSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliveryDate = {"_p_FIX__DeliveryDate", "FIX::DeliveryDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliveryForm = {"_p_FIX__DeliveryForm", "FIX::DeliveryForm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeliveryType = {"_p_FIX__DeliveryType", "FIX::DeliveryType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivFlexProductEligibilityIndicator = {"_p_FIX__DerivFlexProductEligibilityIndicator", "FIX::DerivFlexProductEligibilityIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeCFICode = {"_p_FIX__DerivativeCFICode", "FIX::DerivativeCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeCapPrice = {"_p_FIX__DerivativeCapPrice", "FIX::DerivativeCapPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeContractMultiplier = {"_p_FIX__DerivativeContractMultiplier", "FIX::DerivativeContractMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeContractMultiplierUnit = {"_p_FIX__DerivativeContractMultiplierUnit", "FIX::DerivativeContractMultiplierUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeContractSettlMonth = {"_p_FIX__DerivativeContractSettlMonth", "FIX::DerivativeContractSettlMonth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeCountryOfIssue = {"_p_FIX__DerivativeCountryOfIssue", "FIX::DerivativeCountryOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEncodedIssuer = {"_p_FIX__DerivativeEncodedIssuer", "FIX::DerivativeEncodedIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEncodedIssuerLen = {"_p_FIX__DerivativeEncodedIssuerLen", "FIX::DerivativeEncodedIssuerLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEncodedSecurityDesc = {"_p_FIX__DerivativeEncodedSecurityDesc", "FIX::DerivativeEncodedSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEncodedSecurityDescLen = {"_p_FIX__DerivativeEncodedSecurityDescLen", "FIX::DerivativeEncodedSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventDate = {"_p_FIX__DerivativeEventDate", "FIX::DerivativeEventDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventPx = {"_p_FIX__DerivativeEventPx", "FIX::DerivativeEventPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventText = {"_p_FIX__DerivativeEventText", "FIX::DerivativeEventText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventTime = {"_p_FIX__DerivativeEventTime", "FIX::DerivativeEventTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeEventType = {"_p_FIX__DerivativeEventType", "FIX::DerivativeEventType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeExerciseStyle = {"_p_FIX__DerivativeExerciseStyle", "FIX::DerivativeExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeFloorPrice = {"_p_FIX__DerivativeFloorPrice", "FIX::DerivativeFloorPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeFlowScheduleType = {"_p_FIX__DerivativeFlowScheduleType", "FIX::DerivativeFlowScheduleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeFuturesValuationMethod = {"_p_FIX__DerivativeFuturesValuationMethod", "FIX::DerivativeFuturesValuationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrAttribType = {"_p_FIX__DerivativeInstrAttribType", "FIX::DerivativeInstrAttribType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrAttribValue = {"_p_FIX__DerivativeInstrAttribValue", "FIX::DerivativeInstrAttribValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrRegistry = {"_p_FIX__DerivativeInstrRegistry", "FIX::DerivativeInstrRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrmtAssignmentMethod = {"_p_FIX__DerivativeInstrmtAssignmentMethod", "FIX::DerivativeInstrmtAssignmentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartyID = {"_p_FIX__DerivativeInstrumentPartyID", "FIX::DerivativeInstrumentPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartyIDSource = {"_p_FIX__DerivativeInstrumentPartyIDSource", "FIX::DerivativeInstrumentPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartyRole = {"_p_FIX__DerivativeInstrumentPartyRole", "FIX::DerivativeInstrumentPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartySubID = {"_p_FIX__DerivativeInstrumentPartySubID", "FIX::DerivativeInstrumentPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeInstrumentPartySubIDType = {"_p_FIX__DerivativeInstrumentPartySubIDType", "FIX::DerivativeInstrumentPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeIssueDate = {"_p_FIX__DerivativeIssueDate", "FIX::DerivativeIssueDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeIssuer = {"_p_FIX__DerivativeIssuer", "FIX::DerivativeIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeListMethod = {"_p_FIX__DerivativeListMethod", "FIX::DerivativeListMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeLocaleOfIssue = {"_p_FIX__DerivativeLocaleOfIssue", "FIX::DerivativeLocaleOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMaturityDate = {"_p_FIX__DerivativeMaturityDate", "FIX::DerivativeMaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMaturityMonthYear = {"_p_FIX__DerivativeMaturityMonthYear", "FIX::DerivativeMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMaturityTime = {"_p_FIX__DerivativeMaturityTime", "FIX::DerivativeMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMinPriceIncrement = {"_p_FIX__DerivativeMinPriceIncrement", "FIX::DerivativeMinPriceIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeMinPriceIncrementAmount = {"_p_FIX__DerivativeMinPriceIncrementAmount", "FIX::DerivativeMinPriceIncrementAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeNTPositionLimit = {"_p_FIX__DerivativeNTPositionLimit", "FIX::DerivativeNTPositionLimit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeOptAttribute = {"_p_FIX__DerivativeOptAttribute", "FIX::DerivativeOptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeOptPayAmount = {"_p_FIX__DerivativeOptPayAmount", "FIX::DerivativeOptPayAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePositionLimit = {"_p_FIX__DerivativePositionLimit", "FIX::DerivativePositionLimit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePriceQuoteMethod = {"_p_FIX__DerivativePriceQuoteMethod", "FIX::DerivativePriceQuoteMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePriceUnitOfMeasure = {"_p_FIX__DerivativePriceUnitOfMeasure", "FIX::DerivativePriceUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePriceUnitOfMeasureQty = {"_p_FIX__DerivativePriceUnitOfMeasureQty", "FIX::DerivativePriceUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeProduct = {"_p_FIX__DerivativeProduct", "FIX::DerivativeProduct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeProductComplex = {"_p_FIX__DerivativeProductComplex", "FIX::DerivativeProductComplex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativePutOrCall = {"_p_FIX__DerivativePutOrCall", "FIX::DerivativePutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityAltID = {"_p_FIX__DerivativeSecurityAltID", "FIX::DerivativeSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityAltIDSource = {"_p_FIX__DerivativeSecurityAltIDSource", "FIX::DerivativeSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityDesc = {"_p_FIX__DerivativeSecurityDesc", "FIX::DerivativeSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityExchange = {"_p_FIX__DerivativeSecurityExchange", "FIX::DerivativeSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityGroup = {"_p_FIX__DerivativeSecurityGroup", "FIX::DerivativeSecurityGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityID = {"_p_FIX__DerivativeSecurityID", "FIX::DerivativeSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityIDSource = {"_p_FIX__DerivativeSecurityIDSource", "FIX::DerivativeSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityStatus = {"_p_FIX__DerivativeSecurityStatus", "FIX::DerivativeSecurityStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecuritySubType = {"_p_FIX__DerivativeSecuritySubType", "FIX::DerivativeSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityType = {"_p_FIX__DerivativeSecurityType", "FIX::DerivativeSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityXML = {"_p_FIX__DerivativeSecurityXML", "FIX::DerivativeSecurityXML *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityXMLLen = {"_p_FIX__DerivativeSecurityXMLLen", "FIX::DerivativeSecurityXMLLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSecurityXMLSchema = {"_p_FIX__DerivativeSecurityXMLSchema", "FIX::DerivativeSecurityXMLSchema *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSettlMethod = {"_p_FIX__DerivativeSettlMethod", "FIX::DerivativeSettlMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSettleOnOpenFlag = {"_p_FIX__DerivativeSettleOnOpenFlag", "FIX::DerivativeSettleOnOpenFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStateOrProvinceOfIssue = {"_p_FIX__DerivativeStateOrProvinceOfIssue", "FIX::DerivativeStateOrProvinceOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStrikeCurrency = {"_p_FIX__DerivativeStrikeCurrency", "FIX::DerivativeStrikeCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStrikeMultiplier = {"_p_FIX__DerivativeStrikeMultiplier", "FIX::DerivativeStrikeMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStrikePrice = {"_p_FIX__DerivativeStrikePrice", "FIX::DerivativeStrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeStrikeValue = {"_p_FIX__DerivativeStrikeValue", "FIX::DerivativeStrikeValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSymbol = {"_p_FIX__DerivativeSymbol", "FIX::DerivativeSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeSymbolSfx = {"_p_FIX__DerivativeSymbolSfx", "FIX::DerivativeSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeTimeUnit = {"_p_FIX__DerivativeTimeUnit", "FIX::DerivativeTimeUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeUnitOfMeasure = {"_p_FIX__DerivativeUnitOfMeasure", "FIX::DerivativeUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeUnitOfMeasureQty = {"_p_FIX__DerivativeUnitOfMeasureQty", "FIX::DerivativeUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DerivativeValuationMethod = {"_p_FIX__DerivativeValuationMethod", "FIX::DerivativeValuationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Designation = {"_p_FIX__Designation", "FIX::Designation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeskID = {"_p_FIX__DeskID", "FIX::DeskID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeskOrderHandlingInst = {"_p_FIX__DeskOrderHandlingInst", "FIX::DeskOrderHandlingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeskType = {"_p_FIX__DeskType", "FIX::DeskType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DeskTypeSource = {"_p_FIX__DeskTypeSource", "FIX::DeskTypeSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DetachmentPoint = {"_p_FIX__DetachmentPoint", "FIX::DetachmentPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Dictionary = {"_p_FIX__Dictionary", "FIX::Dictionary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Dictionary__Data__const_iterator = {"_p_FIX__Dictionary__Data__const_iterator", "FIX::Dictionary::Data::const_iterator *|FIX::Dictionary::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionInst = {"_p_FIX__DiscretionInst", "FIX::DiscretionInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionLimitType = {"_p_FIX__DiscretionLimitType", "FIX::DiscretionLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionMoveType = {"_p_FIX__DiscretionMoveType", "FIX::DiscretionMoveType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionOffset = {"_p_FIX__DiscretionOffset", "FIX::DiscretionOffset *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionOffsetType = {"_p_FIX__DiscretionOffsetType", "FIX::DiscretionOffsetType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionOffsetValue = {"_p_FIX__DiscretionOffsetValue", "FIX::DiscretionOffsetValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionPrice = {"_p_FIX__DiscretionPrice", "FIX::DiscretionPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionRoundDirection = {"_p_FIX__DiscretionRoundDirection", "FIX::DiscretionRoundDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DiscretionScope = {"_p_FIX__DiscretionScope", "FIX::DiscretionScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayHighQty = {"_p_FIX__DisplayHighQty", "FIX::DisplayHighQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayLowQty = {"_p_FIX__DisplayLowQty", "FIX::DisplayLowQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayMethod = {"_p_FIX__DisplayMethod", "FIX::DisplayMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayMinIncr = {"_p_FIX__DisplayMinIncr", "FIX::DisplayMinIncr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayQty = {"_p_FIX__DisplayQty", "FIX::DisplayQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DisplayWhen = {"_p_FIX__DisplayWhen", "FIX::DisplayWhen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DistribPaymentMethod = {"_p_FIX__DistribPaymentMethod", "FIX::DistribPaymentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DistribPercentage = {"_p_FIX__DistribPercentage", "FIX::DistribPercentage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DividendYield = {"_p_FIX__DividendYield", "FIX::DividendYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DlvyInst = {"_p_FIX__DlvyInst", "FIX::DlvyInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DlvyInstType = {"_p_FIX__DlvyInstType", "FIX::DlvyInstType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DoNotSend = {"_p_FIX__DoNotSend", "FIX::DoNotSend *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DoubleField = {"_p_FIX__DoubleField", "FIX::DoubleField *|FIX::QtyField *|FIX::PriceField *|FIX::PercentageField *|FIX::AmtField *|FIX::FloatField *|FIX::PriceOffsetField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DueToRelated = {"_p_FIX__DueToRelated", "FIX::DueToRelated *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__DuplicateFieldNumber = {"_p_FIX__DuplicateFieldNumber", "FIX::DuplicateFieldNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EFPTrackingError = {"_p_FIX__EFPTrackingError", "FIX::EFPTrackingError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EXCHANGE = {"_p_FIX__EXCHANGE", "FIX::EXCHANGE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EffectiveTime = {"_p_FIX__EffectiveTime", "FIX::EffectiveTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EmailThreadID = {"_p_FIX__EmailThreadID", "FIX::EmailThreadID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EmailType = {"_p_FIX__EmailType", "FIX::EmailType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedAllocText = {"_p_FIX__EncodedAllocText", "FIX::EncodedAllocText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedAllocTextLen = {"_p_FIX__EncodedAllocTextLen", "FIX::EncodedAllocTextLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedHeadline = {"_p_FIX__EncodedHeadline", "FIX::EncodedHeadline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedHeadlineLen = {"_p_FIX__EncodedHeadlineLen", "FIX::EncodedHeadlineLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedIssuer = {"_p_FIX__EncodedIssuer", "FIX::EncodedIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedIssuerLen = {"_p_FIX__EncodedIssuerLen", "FIX::EncodedIssuerLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedLegIssuer = {"_p_FIX__EncodedLegIssuer", "FIX::EncodedLegIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedLegIssuerLen = {"_p_FIX__EncodedLegIssuerLen", "FIX::EncodedLegIssuerLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedLegSecurityDesc = {"_p_FIX__EncodedLegSecurityDesc", "FIX::EncodedLegSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedLegSecurityDescLen = {"_p_FIX__EncodedLegSecurityDescLen", "FIX::EncodedLegSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedListExecInst = {"_p_FIX__EncodedListExecInst", "FIX::EncodedListExecInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedListExecInstLen = {"_p_FIX__EncodedListExecInstLen", "FIX::EncodedListExecInstLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedListStatusText = {"_p_FIX__EncodedListStatusText", "FIX::EncodedListStatusText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedListStatusTextLen = {"_p_FIX__EncodedListStatusTextLen", "FIX::EncodedListStatusTextLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedMktSegmDesc = {"_p_FIX__EncodedMktSegmDesc", "FIX::EncodedMktSegmDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedMktSegmDescLen = {"_p_FIX__EncodedMktSegmDescLen", "FIX::EncodedMktSegmDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSecurityDesc = {"_p_FIX__EncodedSecurityDesc", "FIX::EncodedSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSecurityDescLen = {"_p_FIX__EncodedSecurityDescLen", "FIX::EncodedSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSecurityListDesc = {"_p_FIX__EncodedSecurityListDesc", "FIX::EncodedSecurityListDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSecurityListDescLen = {"_p_FIX__EncodedSecurityListDescLen", "FIX::EncodedSecurityListDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSubject = {"_p_FIX__EncodedSubject", "FIX::EncodedSubject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedSubjectLen = {"_p_FIX__EncodedSubjectLen", "FIX::EncodedSubjectLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedText = {"_p_FIX__EncodedText", "FIX::EncodedText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedTextLen = {"_p_FIX__EncodedTextLen", "FIX::EncodedTextLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedUnderlyingIssuer = {"_p_FIX__EncodedUnderlyingIssuer", "FIX::EncodedUnderlyingIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedUnderlyingIssuerLen = {"_p_FIX__EncodedUnderlyingIssuerLen", "FIX::EncodedUnderlyingIssuerLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedUnderlyingSecurityDesc = {"_p_FIX__EncodedUnderlyingSecurityDesc", "FIX::EncodedUnderlyingSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncodedUnderlyingSecurityDescLen = {"_p_FIX__EncodedUnderlyingSecurityDescLen", "FIX::EncodedUnderlyingSecurityDescLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptMethod = {"_p_FIX__EncryptMethod", "FIX::EncryptMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedNewPassword = {"_p_FIX__EncryptedNewPassword", "FIX::EncryptedNewPassword *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedNewPasswordLen = {"_p_FIX__EncryptedNewPasswordLen", "FIX::EncryptedNewPasswordLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedPassword = {"_p_FIX__EncryptedPassword", "FIX::EncryptedPassword *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedPasswordLen = {"_p_FIX__EncryptedPasswordLen", "FIX::EncryptedPasswordLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EncryptedPasswordMethod = {"_p_FIX__EncryptedPasswordMethod", "FIX::EncryptedPasswordMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndAccruedInterestAmt = {"_p_FIX__EndAccruedInterestAmt", "FIX::EndAccruedInterestAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndCash = {"_p_FIX__EndCash", "FIX::EndCash *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndDate = {"_p_FIX__EndDate", "FIX::EndDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndMaturityMonthYear = {"_p_FIX__EndMaturityMonthYear", "FIX::EndMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndSeqNo = {"_p_FIX__EndSeqNo", "FIX::EndSeqNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndStrikePxRange = {"_p_FIX__EndStrikePxRange", "FIX::EndStrikePxRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EndTickPriceRange = {"_p_FIX__EndTickPriceRange", "FIX::EndTickPriceRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventDate = {"_p_FIX__EventDate", "FIX::EventDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventPx = {"_p_FIX__EventPx", "FIX::EventPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventText = {"_p_FIX__EventText", "FIX::EventText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventTime = {"_p_FIX__EventTime", "FIX::EventTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__EventType = {"_p_FIX__EventType", "FIX::EventType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExDate = {"_p_FIX__ExDate", "FIX::ExDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExDestination = {"_p_FIX__ExDestination", "FIX::ExDestination *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExDestinationIDSource = {"_p_FIX__ExDestinationIDSource", "FIX::ExDestinationIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Exception = {"_p_FIX__Exception", "FIX::Exception *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExchangeForPhysical = {"_p_FIX__ExchangeForPhysical", "FIX::ExchangeForPhysical *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExchangeRule = {"_p_FIX__ExchangeRule", "FIX::ExchangeRule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExchangeSpecialInstructions = {"_p_FIX__ExchangeSpecialInstructions", "FIX::ExchangeSpecialInstructions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecAckStatus = {"_p_FIX__ExecAckStatus", "FIX::ExecAckStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecBroker = {"_p_FIX__ExecBroker", "FIX::ExecBroker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecID = {"_p_FIX__ExecID", "FIX::ExecID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecInst = {"_p_FIX__ExecInst", "FIX::ExecInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecInstValue = {"_p_FIX__ExecInstValue", "FIX::ExecInstValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecPriceAdjustment = {"_p_FIX__ExecPriceAdjustment", "FIX::ExecPriceAdjustment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecPriceType = {"_p_FIX__ExecPriceType", "FIX::ExecPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecRefID = {"_p_FIX__ExecRefID", "FIX::ExecRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecRestatementReason = {"_p_FIX__ExecRestatementReason", "FIX::ExecRestatementReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecTransType = {"_p_FIX__ExecTransType", "FIX::ExecTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecType = {"_p_FIX__ExecType", "FIX::ExecType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExecValuationPoint = {"_p_FIX__ExecValuationPoint", "FIX::ExecValuationPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExerciseMethod = {"_p_FIX__ExerciseMethod", "FIX::ExerciseMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExerciseStyle = {"_p_FIX__ExerciseStyle", "FIX::ExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpQty = {"_p_FIX__ExpQty", "FIX::ExpQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpType = {"_p_FIX__ExpType", "FIX::ExpType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpirationCycle = {"_p_FIX__ExpirationCycle", "FIX::ExpirationCycle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpirationQtyType = {"_p_FIX__ExpirationQtyType", "FIX::ExpirationQtyType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpireDate = {"_p_FIX__ExpireDate", "FIX::ExpireDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ExpireTime = {"_p_FIX__ExpireTime", "FIX::ExpireTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FLOAT = {"_p_FIX__FLOAT", "FIX::FLOAT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Factor = {"_p_FIX__Factor", "FIX::Factor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FairValue = {"_p_FIX__FairValue", "FIX::FairValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FeeMultiplier = {"_p_FIX__FeeMultiplier", "FIX::FeeMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldBase = {"_p_FIX__FieldBase", "FIX::FieldBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldConvertError = {"_p_FIX__FieldConvertError", "FIX::FieldConvertError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldMap = {"_p_FIX__FieldMap", "FIX::FieldMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldMap__Fields__const_iterator = {"_p_FIX__FieldMap__Fields__const_iterator", "FIX::FieldMap::Fields::const_iterator *|FIX::FieldMap::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldMap__Groups__const_iterator = {"_p_FIX__FieldMap__Groups__const_iterator", "FIX::FieldMap::Groups::const_iterator *|FIX::FieldMap::g_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FieldNotFound = {"_p_FIX__FieldNotFound", "FIX::FieldNotFound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FileLog = {"_p_FIX__FileLog", "FIX::FileLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FileLogFactory = {"_p_FIX__FileLogFactory", "FIX::FileLogFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FileStore = {"_p_FIX__FileStore", "FIX::FileStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FileStoreFactory = {"_p_FIX__FileStoreFactory", "FIX::FileStoreFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FillExecID = {"_p_FIX__FillExecID", "FIX::FillExecID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FillLiquidityInd = {"_p_FIX__FillLiquidityInd", "FIX::FillLiquidityInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FillPx = {"_p_FIX__FillPx", "FIX::FillPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FillQty = {"_p_FIX__FillQty", "FIX::FillQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FinancialStatus = {"_p_FIX__FinancialStatus", "FIX::FinancialStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FirmTradeID = {"_p_FIX__FirmTradeID", "FIX::FirmTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FirstPx = {"_p_FIX__FirstPx", "FIX::FirstPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FlexProductEligibilityIndicator = {"_p_FIX__FlexProductEligibilityIndicator", "FIX::FlexProductEligibilityIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FlexibleIndicator = {"_p_FIX__FlexibleIndicator", "FIX::FlexibleIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FloorPrice = {"_p_FIX__FloorPrice", "FIX::FloorPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FlowScheduleType = {"_p_FIX__FlowScheduleType", "FIX::FlowScheduleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ForexReq = {"_p_FIX__ForexReq", "FIX::ForexReq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FundRenewWaiv = {"_p_FIX__FundRenewWaiv", "FIX::FundRenewWaiv *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FutSettDate = {"_p_FIX__FutSettDate", "FIX::FutSettDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FutSettDate2 = {"_p_FIX__FutSettDate2", "FIX::FutSettDate2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__FuturesValuationMethod = {"_p_FIX__FuturesValuationMethod", "FIX::FuturesValuationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__GTBookingInst = {"_p_FIX__GTBookingInst", "FIX::GTBookingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__GapFillFlag = {"_p_FIX__GapFillFlag", "FIX::GapFillFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__GrossTradeAmt = {"_p_FIX__GrossTradeAmt", "FIX::GrossTradeAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Group = {"_p_FIX__Group", "FIX::Group *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HaltReasonChar = {"_p_FIX__HaltReasonChar", "FIX::HaltReasonChar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HaltReasonInt = {"_p_FIX__HaltReasonInt", "FIX::HaltReasonInt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HandlInst = {"_p_FIX__HandlInst", "FIX::HandlInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Header = {"_p_FIX__Header", "FIX::Header *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Headline = {"_p_FIX__Headline", "FIX::Headline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HeartBtInt = {"_p_FIX__HeartBtInt", "FIX::HeartBtInt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HighLimitPrice = {"_p_FIX__HighLimitPrice", "FIX::HighLimitPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HighPx = {"_p_FIX__HighPx", "FIX::HighPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HopCompID = {"_p_FIX__HopCompID", "FIX::HopCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HopRefID = {"_p_FIX__HopRefID", "FIX::HopRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HopSendingTime = {"_p_FIX__HopSendingTime", "FIX::HopSendingTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__HostCrossID = {"_p_FIX__HostCrossID", "FIX::HostCrossID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IDSource = {"_p_FIX__IDSource", "FIX::IDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__INT = {"_p_FIX__INT", "FIX::INT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOException = {"_p_FIX__IOException", "FIX::IOException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIID = {"_p_FIX__IOIID", "FIX::IOIID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOINaturalFlag = {"_p_FIX__IOINaturalFlag", "FIX::IOINaturalFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIOthSvc = {"_p_FIX__IOIOthSvc", "FIX::IOIOthSvc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIQltyInd = {"_p_FIX__IOIQltyInd", "FIX::IOIQltyInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIQty = {"_p_FIX__IOIQty", "FIX::IOIQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIQualifier = {"_p_FIX__IOIQualifier", "FIX::IOIQualifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIRefID = {"_p_FIX__IOIRefID", "FIX::IOIRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIShares = {"_p_FIX__IOIShares", "FIX::IOIShares *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOITransType = {"_p_FIX__IOITransType", "FIX::IOITransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IOIid = {"_p_FIX__IOIid", "FIX::IOIid *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ImpliedMarketIndicator = {"_p_FIX__ImpliedMarketIndicator", "FIX::ImpliedMarketIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InViewOfCommon = {"_p_FIX__InViewOfCommon", "FIX::InViewOfCommon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IncTaxInd = {"_p_FIX__IncTaxInd", "FIX::IncTaxInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IncorrectDataFormat = {"_p_FIX__IncorrectDataFormat", "FIX::IncorrectDataFormat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IncorrectMessageStructure = {"_p_FIX__IncorrectMessageStructure", "FIX::IncorrectMessageStructure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IncorrectTagValue = {"_p_FIX__IncorrectTagValue", "FIX::IncorrectTagValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IndividualAllocID = {"_p_FIX__IndividualAllocID", "FIX::IndividualAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IndividualAllocRejCode = {"_p_FIX__IndividualAllocRejCode", "FIX::IndividualAllocRejCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IndividualAllocType = {"_p_FIX__IndividualAllocType", "FIX::IndividualAllocType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Initiator = {"_p_FIX__Initiator", "FIX::Initiator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InputSource = {"_p_FIX__InputSource", "FIX::InputSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrAttribType = {"_p_FIX__InstrAttribType", "FIX::InstrAttribType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrAttribValue = {"_p_FIX__InstrAttribValue", "FIX::InstrAttribValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrRegistry = {"_p_FIX__InstrRegistry", "FIX::InstrRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrmtAssignmentMethod = {"_p_FIX__InstrmtAssignmentMethod", "FIX::InstrmtAssignmentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartyID = {"_p_FIX__InstrumentPartyID", "FIX::InstrumentPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartyIDSource = {"_p_FIX__InstrumentPartyIDSource", "FIX::InstrumentPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartyRole = {"_p_FIX__InstrumentPartyRole", "FIX::InstrumentPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartySubID = {"_p_FIX__InstrumentPartySubID", "FIX::InstrumentPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InstrumentPartySubIDType = {"_p_FIX__InstrumentPartySubIDType", "FIX::InstrumentPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IntField = {"_p_FIX__IntField", "FIX::IntField *|FIX::LengthField *|FIX::NumInGroupField *|FIX::SeqNumField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InterestAccrualDate = {"_p_FIX__InterestAccrualDate", "FIX::InterestAccrualDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InterestAtMaturity = {"_p_FIX__InterestAtMaturity", "FIX::InterestAtMaturity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InvalidMessage = {"_p_FIX__InvalidMessage", "FIX::InvalidMessage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InvalidMessageType = {"_p_FIX__InvalidMessageType", "FIX::InvalidMessageType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InvalidTagNumber = {"_p_FIX__InvalidTagNumber", "FIX::InvalidTagNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__InvestorCountryOfResidence = {"_p_FIX__InvestorCountryOfResidence", "FIX::InvestorCountryOfResidence *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__IssueDate = {"_p_FIX__IssueDate", "FIX::IssueDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Issuer = {"_p_FIX__Issuer", "FIX::Issuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LANGUAGE = {"_p_FIX__LANGUAGE", "FIX::LANGUAGE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LENGTH = {"_p_FIX__LENGTH", "FIX::LENGTH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LOCALMKTDATE = {"_p_FIX__LOCALMKTDATE", "FIX::LOCALMKTDATE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LanguageCode = {"_p_FIX__LanguageCode", "FIX::LanguageCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastCapacity = {"_p_FIX__LastCapacity", "FIX::LastCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastForwardPoints = {"_p_FIX__LastForwardPoints", "FIX::LastForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastForwardPoints2 = {"_p_FIX__LastForwardPoints2", "FIX::LastForwardPoints2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastFragment = {"_p_FIX__LastFragment", "FIX::LastFragment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastLiquidityInd = {"_p_FIX__LastLiquidityInd", "FIX::LastLiquidityInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastMkt = {"_p_FIX__LastMkt", "FIX::LastMkt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastMsgSeqNumProcessed = {"_p_FIX__LastMsgSeqNumProcessed", "FIX::LastMsgSeqNumProcessed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastNetworkResponseID = {"_p_FIX__LastNetworkResponseID", "FIX::LastNetworkResponseID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastParPx = {"_p_FIX__LastParPx", "FIX::LastParPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastPx = {"_p_FIX__LastPx", "FIX::LastPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastQty = {"_p_FIX__LastQty", "FIX::LastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastRptRequested = {"_p_FIX__LastRptRequested", "FIX::LastRptRequested *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastShares = {"_p_FIX__LastShares", "FIX::LastShares *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastSpotRate = {"_p_FIX__LastSpotRate", "FIX::LastSpotRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastSwapPoints = {"_p_FIX__LastSwapPoints", "FIX::LastSwapPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LastUpdateTime = {"_p_FIX__LastUpdateTime", "FIX::LastUpdateTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LateIndicator = {"_p_FIX__LateIndicator", "FIX::LateIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LeavesQty = {"_p_FIX__LeavesQty", "FIX::LeavesQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocAccount = {"_p_FIX__LegAllocAccount", "FIX::LegAllocAccount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocAcctIDSource = {"_p_FIX__LegAllocAcctIDSource", "FIX::LegAllocAcctIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocID = {"_p_FIX__LegAllocID", "FIX::LegAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocQty = {"_p_FIX__LegAllocQty", "FIX::LegAllocQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegAllocSettlCurrency = {"_p_FIX__LegAllocSettlCurrency", "FIX::LegAllocSettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkCurveCurrency = {"_p_FIX__LegBenchmarkCurveCurrency", "FIX::LegBenchmarkCurveCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkCurveName = {"_p_FIX__LegBenchmarkCurveName", "FIX::LegBenchmarkCurveName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkCurvePoint = {"_p_FIX__LegBenchmarkCurvePoint", "FIX::LegBenchmarkCurvePoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkPrice = {"_p_FIX__LegBenchmarkPrice", "FIX::LegBenchmarkPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBenchmarkPriceType = {"_p_FIX__LegBenchmarkPriceType", "FIX::LegBenchmarkPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBidForwardPoints = {"_p_FIX__LegBidForwardPoints", "FIX::LegBidForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegBidPx = {"_p_FIX__LegBidPx", "FIX::LegBidPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCFICode = {"_p_FIX__LegCFICode", "FIX::LegCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCalculatedCcyLastQty = {"_p_FIX__LegCalculatedCcyLastQty", "FIX::LegCalculatedCcyLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegContractMultiplier = {"_p_FIX__LegContractMultiplier", "FIX::LegContractMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegContractMultiplierUnit = {"_p_FIX__LegContractMultiplierUnit", "FIX::LegContractMultiplierUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegContractSettlMonth = {"_p_FIX__LegContractSettlMonth", "FIX::LegContractSettlMonth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCountryOfIssue = {"_p_FIX__LegCountryOfIssue", "FIX::LegCountryOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCouponPaymentDate = {"_p_FIX__LegCouponPaymentDate", "FIX::LegCouponPaymentDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCouponRate = {"_p_FIX__LegCouponRate", "FIX::LegCouponRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCoveredOrUncovered = {"_p_FIX__LegCoveredOrUncovered", "FIX::LegCoveredOrUncovered *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCreditRating = {"_p_FIX__LegCreditRating", "FIX::LegCreditRating *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCurrency = {"_p_FIX__LegCurrency", "FIX::LegCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegCurrencyRatio = {"_p_FIX__LegCurrencyRatio", "FIX::LegCurrencyRatio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegDatedDate = {"_p_FIX__LegDatedDate", "FIX::LegDatedDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegDividendYield = {"_p_FIX__LegDividendYield", "FIX::LegDividendYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegExecInst = {"_p_FIX__LegExecInst", "FIX::LegExecInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegExerciseStyle = {"_p_FIX__LegExerciseStyle", "FIX::LegExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegFactor = {"_p_FIX__LegFactor", "FIX::LegFactor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegFlowScheduleType = {"_p_FIX__LegFlowScheduleType", "FIX::LegFlowScheduleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegFutSettDate = {"_p_FIX__LegFutSettDate", "FIX::LegFutSettDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegGrossTradeAmt = {"_p_FIX__LegGrossTradeAmt", "FIX::LegGrossTradeAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegIOIQty = {"_p_FIX__LegIOIQty", "FIX::LegIOIQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegIndividualAllocID = {"_p_FIX__LegIndividualAllocID", "FIX::LegIndividualAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegInstrRegistry = {"_p_FIX__LegInstrRegistry", "FIX::LegInstrRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegInterestAccrualDate = {"_p_FIX__LegInterestAccrualDate", "FIX::LegInterestAccrualDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegIssueDate = {"_p_FIX__LegIssueDate", "FIX::LegIssueDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegIssuer = {"_p_FIX__LegIssuer", "FIX::LegIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegLastForwardPoints = {"_p_FIX__LegLastForwardPoints", "FIX::LegLastForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegLastPx = {"_p_FIX__LegLastPx", "FIX::LegLastPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegLastQty = {"_p_FIX__LegLastQty", "FIX::LegLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegLocaleOfIssue = {"_p_FIX__LegLocaleOfIssue", "FIX::LegLocaleOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegMaturityDate = {"_p_FIX__LegMaturityDate", "FIX::LegMaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegMaturityMonthYear = {"_p_FIX__LegMaturityMonthYear", "FIX::LegMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegMaturityTime = {"_p_FIX__LegMaturityTime", "FIX::LegMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegNumber = {"_p_FIX__LegNumber", "FIX::LegNumber *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOfferForwardPoints = {"_p_FIX__LegOfferForwardPoints", "FIX::LegOfferForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOfferPx = {"_p_FIX__LegOfferPx", "FIX::LegOfferPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOptAttribute = {"_p_FIX__LegOptAttribute", "FIX::LegOptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOptionRatio = {"_p_FIX__LegOptionRatio", "FIX::LegOptionRatio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegOrderQty = {"_p_FIX__LegOrderQty", "FIX::LegOrderQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPool = {"_p_FIX__LegPool", "FIX::LegPool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPositionEffect = {"_p_FIX__LegPositionEffect", "FIX::LegPositionEffect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPrice = {"_p_FIX__LegPrice", "FIX::LegPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPriceType = {"_p_FIX__LegPriceType", "FIX::LegPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPriceUnitOfMeasure = {"_p_FIX__LegPriceUnitOfMeasure", "FIX::LegPriceUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPriceUnitOfMeasureQty = {"_p_FIX__LegPriceUnitOfMeasureQty", "FIX::LegPriceUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegProduct = {"_p_FIX__LegProduct", "FIX::LegProduct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegPutOrCall = {"_p_FIX__LegPutOrCall", "FIX::LegPutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegQty = {"_p_FIX__LegQty", "FIX::LegQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRatioQty = {"_p_FIX__LegRatioQty", "FIX::LegRatioQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRedemptionDate = {"_p_FIX__LegRedemptionDate", "FIX::LegRedemptionDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRefID = {"_p_FIX__LegRefID", "FIX::LegRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRepoCollateralSecurityType = {"_p_FIX__LegRepoCollateralSecurityType", "FIX::LegRepoCollateralSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegReportID = {"_p_FIX__LegReportID", "FIX::LegReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRepurchaseRate = {"_p_FIX__LegRepurchaseRate", "FIX::LegRepurchaseRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegRepurchaseTerm = {"_p_FIX__LegRepurchaseTerm", "FIX::LegRepurchaseTerm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityAltID = {"_p_FIX__LegSecurityAltID", "FIX::LegSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityAltIDSource = {"_p_FIX__LegSecurityAltIDSource", "FIX::LegSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityDesc = {"_p_FIX__LegSecurityDesc", "FIX::LegSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityExchange = {"_p_FIX__LegSecurityExchange", "FIX::LegSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityID = {"_p_FIX__LegSecurityID", "FIX::LegSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityIDSource = {"_p_FIX__LegSecurityIDSource", "FIX::LegSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecuritySubType = {"_p_FIX__LegSecuritySubType", "FIX::LegSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSecurityType = {"_p_FIX__LegSecurityType", "FIX::LegSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSettlCurrency = {"_p_FIX__LegSettlCurrency", "FIX::LegSettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSettlDate = {"_p_FIX__LegSettlDate", "FIX::LegSettlDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSettlType = {"_p_FIX__LegSettlType", "FIX::LegSettlType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSettlmntTyp = {"_p_FIX__LegSettlmntTyp", "FIX::LegSettlmntTyp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSide = {"_p_FIX__LegSide", "FIX::LegSide *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStateOrProvinceOfIssue = {"_p_FIX__LegStateOrProvinceOfIssue", "FIX::LegStateOrProvinceOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStipulationType = {"_p_FIX__LegStipulationType", "FIX::LegStipulationType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStipulationValue = {"_p_FIX__LegStipulationValue", "FIX::LegStipulationValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStrikeCurrency = {"_p_FIX__LegStrikeCurrency", "FIX::LegStrikeCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegStrikePrice = {"_p_FIX__LegStrikePrice", "FIX::LegStrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSwapType = {"_p_FIX__LegSwapType", "FIX::LegSwapType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSymbol = {"_p_FIX__LegSymbol", "FIX::LegSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegSymbolSfx = {"_p_FIX__LegSymbolSfx", "FIX::LegSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegTimeUnit = {"_p_FIX__LegTimeUnit", "FIX::LegTimeUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegUnitOfMeasure = {"_p_FIX__LegUnitOfMeasure", "FIX::LegUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegUnitOfMeasureQty = {"_p_FIX__LegUnitOfMeasureQty", "FIX::LegUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegVolatility = {"_p_FIX__LegVolatility", "FIX::LegVolatility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LegalConfirm = {"_p_FIX__LegalConfirm", "FIX::LegalConfirm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LinesOfText = {"_p_FIX__LinesOfText", "FIX::LinesOfText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityIndType = {"_p_FIX__LiquidityIndType", "FIX::LiquidityIndType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityNumSecurities = {"_p_FIX__LiquidityNumSecurities", "FIX::LiquidityNumSecurities *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityPctHigh = {"_p_FIX__LiquidityPctHigh", "FIX::LiquidityPctHigh *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityPctLow = {"_p_FIX__LiquidityPctLow", "FIX::LiquidityPctLow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LiquidityValue = {"_p_FIX__LiquidityValue", "FIX::LiquidityValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListExecInst = {"_p_FIX__ListExecInst", "FIX::ListExecInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListExecInstType = {"_p_FIX__ListExecInstType", "FIX::ListExecInstType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListID = {"_p_FIX__ListID", "FIX::ListID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListMethod = {"_p_FIX__ListMethod", "FIX::ListMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListName = {"_p_FIX__ListName", "FIX::ListName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListNoOrds = {"_p_FIX__ListNoOrds", "FIX::ListNoOrds *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListOrderStatus = {"_p_FIX__ListOrderStatus", "FIX::ListOrderStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListRejectReason = {"_p_FIX__ListRejectReason", "FIX::ListRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListSeqNo = {"_p_FIX__ListSeqNo", "FIX::ListSeqNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListStatusText = {"_p_FIX__ListStatusText", "FIX::ListStatusText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListStatusType = {"_p_FIX__ListStatusType", "FIX::ListStatusType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ListUpdateAction = {"_p_FIX__ListUpdateAction", "FIX::ListUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LocaleOfIssue = {"_p_FIX__LocaleOfIssue", "FIX::LocaleOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LocateReqd = {"_p_FIX__LocateReqd", "FIX::LocateReqd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LocationID = {"_p_FIX__LocationID", "FIX::LocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Log = {"_p_FIX__Log", "FIX::Log *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LogFactory = {"_p_FIX__LogFactory", "FIX::LogFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LongQty = {"_p_FIX__LongQty", "FIX::LongQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LotType = {"_p_FIX__LotType", "FIX::LotType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LowLimitPrice = {"_p_FIX__LowLimitPrice", "FIX::LowLimitPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__LowPx = {"_p_FIX__LowPx", "FIX::LowPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDBookType = {"_p_FIX__MDBookType", "FIX::MDBookType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryBuyer = {"_p_FIX__MDEntryBuyer", "FIX::MDEntryBuyer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryDate = {"_p_FIX__MDEntryDate", "FIX::MDEntryDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryForwardPoints = {"_p_FIX__MDEntryForwardPoints", "FIX::MDEntryForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryID = {"_p_FIX__MDEntryID", "FIX::MDEntryID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryOriginator = {"_p_FIX__MDEntryOriginator", "FIX::MDEntryOriginator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryPositionNo = {"_p_FIX__MDEntryPositionNo", "FIX::MDEntryPositionNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryPx = {"_p_FIX__MDEntryPx", "FIX::MDEntryPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryRefID = {"_p_FIX__MDEntryRefID", "FIX::MDEntryRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntrySeller = {"_p_FIX__MDEntrySeller", "FIX::MDEntrySeller *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntrySize = {"_p_FIX__MDEntrySize", "FIX::MDEntrySize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntrySpotRate = {"_p_FIX__MDEntrySpotRate", "FIX::MDEntrySpotRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryTime = {"_p_FIX__MDEntryTime", "FIX::MDEntryTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDEntryType = {"_p_FIX__MDEntryType", "FIX::MDEntryType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDFeedType = {"_p_FIX__MDFeedType", "FIX::MDFeedType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDImplicitDelete = {"_p_FIX__MDImplicitDelete", "FIX::MDImplicitDelete *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDMkt = {"_p_FIX__MDMkt", "FIX::MDMkt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDOriginType = {"_p_FIX__MDOriginType", "FIX::MDOriginType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDPriceLevel = {"_p_FIX__MDPriceLevel", "FIX::MDPriceLevel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDQuoteType = {"_p_FIX__MDQuoteType", "FIX::MDQuoteType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDReportID = {"_p_FIX__MDReportID", "FIX::MDReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDReqID = {"_p_FIX__MDReqID", "FIX::MDReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDReqRejReason = {"_p_FIX__MDReqRejReason", "FIX::MDReqRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDSecSize = {"_p_FIX__MDSecSize", "FIX::MDSecSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDSecSizeType = {"_p_FIX__MDSecSizeType", "FIX::MDSecSizeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDStreamID = {"_p_FIX__MDStreamID", "FIX::MDStreamID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDSubBookType = {"_p_FIX__MDSubBookType", "FIX::MDSubBookType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDUpdateAction = {"_p_FIX__MDUpdateAction", "FIX::MDUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MDUpdateType = {"_p_FIX__MDUpdateType", "FIX::MDUpdateType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MONTHYEAR = {"_p_FIX__MONTHYEAR", "FIX::MONTHYEAR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MULTIPLECHARVALUE = {"_p_FIX__MULTIPLECHARVALUE", "FIX::MULTIPLECHARVALUE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MULTIPLESTRINGVALUE = {"_p_FIX__MULTIPLESTRINGVALUE", "FIX::MULTIPLESTRINGVALUE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MULTIPLEVALUESTRING = {"_p_FIX__MULTIPLEVALUESTRING", "FIX::MULTIPLEVALUESTRING *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MailingDtls = {"_p_FIX__MailingDtls", "FIX::MailingDtls *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MailingInst = {"_p_FIX__MailingInst", "FIX::MailingInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ManualOrderIndicator = {"_p_FIX__ManualOrderIndicator", "FIX::ManualOrderIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarginExcess = {"_p_FIX__MarginExcess", "FIX::MarginExcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarginRatio = {"_p_FIX__MarginRatio", "FIX::MarginRatio *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketDepth = {"_p_FIX__MarketDepth", "FIX::MarketDepth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketID = {"_p_FIX__MarketID", "FIX::MarketID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketReportID = {"_p_FIX__MarketReportID", "FIX::MarketReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketReqID = {"_p_FIX__MarketReqID", "FIX::MarketReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketSegmentDesc = {"_p_FIX__MarketSegmentDesc", "FIX::MarketSegmentDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketSegmentID = {"_p_FIX__MarketSegmentID", "FIX::MarketSegmentID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MarketUpdateAction = {"_p_FIX__MarketUpdateAction", "FIX::MarketUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionRejectReason = {"_p_FIX__MassActionRejectReason", "FIX::MassActionRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionReportID = {"_p_FIX__MassActionReportID", "FIX::MassActionReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionResponse = {"_p_FIX__MassActionResponse", "FIX::MassActionResponse *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionScope = {"_p_FIX__MassActionScope", "FIX::MassActionScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassActionType = {"_p_FIX__MassActionType", "FIX::MassActionType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassCancelRejectReason = {"_p_FIX__MassCancelRejectReason", "FIX::MassCancelRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassCancelRequestType = {"_p_FIX__MassCancelRequestType", "FIX::MassCancelRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassCancelResponse = {"_p_FIX__MassCancelResponse", "FIX::MassCancelResponse *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassStatusReqID = {"_p_FIX__MassStatusReqID", "FIX::MassStatusReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MassStatusReqType = {"_p_FIX__MassStatusReqType", "FIX::MassStatusReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MatchAlgorithm = {"_p_FIX__MatchAlgorithm", "FIX::MatchAlgorithm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MatchIncrement = {"_p_FIX__MatchIncrement", "FIX::MatchIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MatchStatus = {"_p_FIX__MatchStatus", "FIX::MatchStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MatchType = {"_p_FIX__MatchType", "FIX::MatchType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityDate = {"_p_FIX__MaturityDate", "FIX::MaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityDay = {"_p_FIX__MaturityDay", "FIX::MaturityDay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityMonthYear = {"_p_FIX__MaturityMonthYear", "FIX::MaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityMonthYearFormat = {"_p_FIX__MaturityMonthYearFormat", "FIX::MaturityMonthYearFormat *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityMonthYearIncrement = {"_p_FIX__MaturityMonthYearIncrement", "FIX::MaturityMonthYearIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityMonthYearIncrementUnits = {"_p_FIX__MaturityMonthYearIncrementUnits", "FIX::MaturityMonthYearIncrementUnits *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityNetMoney = {"_p_FIX__MaturityNetMoney", "FIX::MaturityNetMoney *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityRuleID = {"_p_FIX__MaturityRuleID", "FIX::MaturityRuleID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaturityTime = {"_p_FIX__MaturityTime", "FIX::MaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxFloor = {"_p_FIX__MaxFloor", "FIX::MaxFloor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxMessageSize = {"_p_FIX__MaxMessageSize", "FIX::MaxMessageSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxPriceLevels = {"_p_FIX__MaxPriceLevels", "FIX::MaxPriceLevels *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxPriceVariation = {"_p_FIX__MaxPriceVariation", "FIX::MaxPriceVariation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxShow = {"_p_FIX__MaxShow", "FIX::MaxShow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MaxTradeVol = {"_p_FIX__MaxTradeVol", "FIX::MaxTradeVol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MemoryStore = {"_p_FIX__MemoryStore", "FIX::MemoryStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MemoryStoreFactory = {"_p_FIX__MemoryStoreFactory", "FIX::MemoryStoreFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Message = {"_p_FIX__Message", "FIX::Message *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageEncoding = {"_p_FIX__MessageEncoding", "FIX::MessageEncoding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageEventSource = {"_p_FIX__MessageEventSource", "FIX::MessageEventSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageParseError = {"_p_FIX__MessageParseError", "FIX::MessageParseError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageStore = {"_p_FIX__MessageStore", "FIX::MessageStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageStoreExceptionWrapper = {"_p_FIX__MessageStoreExceptionWrapper", "FIX::MessageStoreExceptionWrapper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageStoreFactory = {"_p_FIX__MessageStoreFactory", "FIX::MessageStoreFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MessageStoreFactoryExceptionWrapper = {"_p_FIX__MessageStoreFactoryExceptionWrapper", "FIX::MessageStoreFactoryExceptionWrapper *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MidPx = {"_p_FIX__MidPx", "FIX::MidPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MidYield = {"_p_FIX__MidYield", "FIX::MidYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinBidSize = {"_p_FIX__MinBidSize", "FIX::MinBidSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinLotSize = {"_p_FIX__MinLotSize", "FIX::MinLotSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinOfferSize = {"_p_FIX__MinOfferSize", "FIX::MinOfferSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinPriceIncrement = {"_p_FIX__MinPriceIncrement", "FIX::MinPriceIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinPriceIncrementAmount = {"_p_FIX__MinPriceIncrementAmount", "FIX::MinPriceIncrementAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinQty = {"_p_FIX__MinQty", "FIX::MinQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MinTradeVol = {"_p_FIX__MinTradeVol", "FIX::MinTradeVol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MiscFeeAmt = {"_p_FIX__MiscFeeAmt", "FIX::MiscFeeAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MiscFeeBasis = {"_p_FIX__MiscFeeBasis", "FIX::MiscFeeBasis *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MiscFeeCurr = {"_p_FIX__MiscFeeCurr", "FIX::MiscFeeCurr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MiscFeeType = {"_p_FIX__MiscFeeType", "FIX::MiscFeeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MktBidPx = {"_p_FIX__MktBidPx", "FIX::MktBidPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MktOfferPx = {"_p_FIX__MktOfferPx", "FIX::MktOfferPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ModelType = {"_p_FIX__ModelType", "FIX::ModelType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MoneyLaunderingStatus = {"_p_FIX__MoneyLaunderingStatus", "FIX::MoneyLaunderingStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MsgDirection = {"_p_FIX__MsgDirection", "FIX::MsgDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MsgSeqNum = {"_p_FIX__MsgSeqNum", "FIX::MsgSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MsgType = {"_p_FIX__MsgType", "FIX::MsgType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MultiLegReportingType = {"_p_FIX__MultiLegReportingType", "FIX::MultiLegReportingType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MultiLegRptTypeReq = {"_p_FIX__MultiLegRptTypeReq", "FIX::MultiLegRptTypeReq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MultilegModel = {"_p_FIX__MultilegModel", "FIX::MultilegModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__MultilegPriceMethod = {"_p_FIX__MultilegPriceMethod", "FIX::MultilegPriceMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NTPositionLimit = {"_p_FIX__NTPositionLimit", "FIX::NTPositionLimit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NUMINGROUP = {"_p_FIX__NUMINGROUP", "FIX::NUMINGROUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartyID = {"_p_FIX__Nested2PartyID", "FIX::Nested2PartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartyIDSource = {"_p_FIX__Nested2PartyIDSource", "FIX::Nested2PartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartyRole = {"_p_FIX__Nested2PartyRole", "FIX::Nested2PartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartySubID = {"_p_FIX__Nested2PartySubID", "FIX::Nested2PartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested2PartySubIDType = {"_p_FIX__Nested2PartySubIDType", "FIX::Nested2PartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartyID = {"_p_FIX__Nested3PartyID", "FIX::Nested3PartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartyIDSource = {"_p_FIX__Nested3PartyIDSource", "FIX::Nested3PartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartyRole = {"_p_FIX__Nested3PartyRole", "FIX::Nested3PartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartySubID = {"_p_FIX__Nested3PartySubID", "FIX::Nested3PartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested3PartySubIDType = {"_p_FIX__Nested3PartySubIDType", "FIX::Nested3PartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartyID = {"_p_FIX__Nested4PartyID", "FIX::Nested4PartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartyIDSource = {"_p_FIX__Nested4PartyIDSource", "FIX::Nested4PartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartyRole = {"_p_FIX__Nested4PartyRole", "FIX::Nested4PartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartySubID = {"_p_FIX__Nested4PartySubID", "FIX::Nested4PartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Nested4PartySubIDType = {"_p_FIX__Nested4PartySubIDType", "FIX::Nested4PartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedInstrAttribType = {"_p_FIX__NestedInstrAttribType", "FIX::NestedInstrAttribType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedInstrAttribValue = {"_p_FIX__NestedInstrAttribValue", "FIX::NestedInstrAttribValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartyID = {"_p_FIX__NestedPartyID", "FIX::NestedPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartyIDSource = {"_p_FIX__NestedPartyIDSource", "FIX::NestedPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartyRole = {"_p_FIX__NestedPartyRole", "FIX::NestedPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartySubID = {"_p_FIX__NestedPartySubID", "FIX::NestedPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NestedPartySubIDType = {"_p_FIX__NestedPartySubIDType", "FIX::NestedPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetChgPrevDay = {"_p_FIX__NetChgPrevDay", "FIX::NetChgPrevDay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetGrossInd = {"_p_FIX__NetGrossInd", "FIX::NetGrossInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetMoney = {"_p_FIX__NetMoney", "FIX::NetMoney *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetworkRequestID = {"_p_FIX__NetworkRequestID", "FIX::NetworkRequestID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetworkRequestType = {"_p_FIX__NetworkRequestType", "FIX::NetworkRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetworkResponseID = {"_p_FIX__NetworkResponseID", "FIX::NetworkResponseID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NetworkStatusResponseType = {"_p_FIX__NetworkStatusResponseType", "FIX::NetworkStatusResponseType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewPassword = {"_p_FIX__NewPassword", "FIX::NewPassword *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewSeqNo = {"_p_FIX__NewSeqNo", "FIX::NewSeqNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewsCategory = {"_p_FIX__NewsCategory", "FIX::NewsCategory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewsID = {"_p_FIX__NewsID", "FIX::NewsID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewsRefID = {"_p_FIX__NewsRefID", "FIX::NewsRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NewsRefType = {"_p_FIX__NewsRefType", "FIX::NewsRefType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NextExpectedMsgSeqNum = {"_p_FIX__NextExpectedMsgSeqNum", "FIX::NextExpectedMsgSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoAffectedOrders = {"_p_FIX__NoAffectedOrders", "FIX::NoAffectedOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoAllocs = {"_p_FIX__NoAllocs", "FIX::NoAllocs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoAltMDSource = {"_p_FIX__NoAltMDSource", "FIX::NoAltMDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoApplIDs = {"_p_FIX__NoApplIDs", "FIX::NoApplIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoAsgnReqs = {"_p_FIX__NoAsgnReqs", "FIX::NoAsgnReqs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoBidComponents = {"_p_FIX__NoBidComponents", "FIX::NoBidComponents *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoBidDescriptors = {"_p_FIX__NoBidDescriptors", "FIX::NoBidDescriptors *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoCapacities = {"_p_FIX__NoCapacities", "FIX::NoCapacities *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoClearingInstructions = {"_p_FIX__NoClearingInstructions", "FIX::NoClearingInstructions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoCollInquiryQualifier = {"_p_FIX__NoCollInquiryQualifier", "FIX::NoCollInquiryQualifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoCompIDs = {"_p_FIX__NoCompIDs", "FIX::NoCompIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoComplexEventDates = {"_p_FIX__NoComplexEventDates", "FIX::NoComplexEventDates *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoComplexEventTimes = {"_p_FIX__NoComplexEventTimes", "FIX::NoComplexEventTimes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoComplexEvents = {"_p_FIX__NoComplexEvents", "FIX::NoComplexEvents *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoContAmts = {"_p_FIX__NoContAmts", "FIX::NoContAmts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoContraBrokers = {"_p_FIX__NoContraBrokers", "FIX::NoContraBrokers *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDates = {"_p_FIX__NoDates", "FIX::NoDates *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeEvents = {"_p_FIX__NoDerivativeEvents", "FIX::NoDerivativeEvents *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeInstrAttrib = {"_p_FIX__NoDerivativeInstrAttrib", "FIX::NoDerivativeInstrAttrib *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeInstrumentParties = {"_p_FIX__NoDerivativeInstrumentParties", "FIX::NoDerivativeInstrumentParties *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeInstrumentPartySubIDs = {"_p_FIX__NoDerivativeInstrumentPartySubIDs", "FIX::NoDerivativeInstrumentPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDerivativeSecurityAltID = {"_p_FIX__NoDerivativeSecurityAltID", "FIX::NoDerivativeSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDistribInsts = {"_p_FIX__NoDistribInsts", "FIX::NoDistribInsts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoDlvyInst = {"_p_FIX__NoDlvyInst", "FIX::NoDlvyInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoEvents = {"_p_FIX__NoEvents", "FIX::NoEvents *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoExecInstRules = {"_p_FIX__NoExecInstRules", "FIX::NoExecInstRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoExecs = {"_p_FIX__NoExecs", "FIX::NoExecs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoExpiration = {"_p_FIX__NoExpiration", "FIX::NoExpiration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoFills = {"_p_FIX__NoFills", "FIX::NoFills *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoHops = {"_p_FIX__NoHops", "FIX::NoHops *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoIOIQualifiers = {"_p_FIX__NoIOIQualifiers", "FIX::NoIOIQualifiers *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoInstrAttrib = {"_p_FIX__NoInstrAttrib", "FIX::NoInstrAttrib *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoInstrumentParties = {"_p_FIX__NoInstrumentParties", "FIX::NoInstrumentParties *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoInstrumentPartySubIDs = {"_p_FIX__NoInstrumentPartySubIDs", "FIX::NoInstrumentPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLegAllocs = {"_p_FIX__NoLegAllocs", "FIX::NoLegAllocs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLegSecurityAltID = {"_p_FIX__NoLegSecurityAltID", "FIX::NoLegSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLegStipulations = {"_p_FIX__NoLegStipulations", "FIX::NoLegStipulations *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLegs = {"_p_FIX__NoLegs", "FIX::NoLegs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLinesOfText = {"_p_FIX__NoLinesOfText", "FIX::NoLinesOfText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoLotTypeRules = {"_p_FIX__NoLotTypeRules", "FIX::NoLotTypeRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMDEntries = {"_p_FIX__NoMDEntries", "FIX::NoMDEntries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMDEntryTypes = {"_p_FIX__NoMDEntryTypes", "FIX::NoMDEntryTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMDFeedTypes = {"_p_FIX__NoMDFeedTypes", "FIX::NoMDFeedTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMarketSegments = {"_p_FIX__NoMarketSegments", "FIX::NoMarketSegments *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMatchRules = {"_p_FIX__NoMatchRules", "FIX::NoMatchRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMaturityRules = {"_p_FIX__NoMaturityRules", "FIX::NoMaturityRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMiscFees = {"_p_FIX__NoMiscFees", "FIX::NoMiscFees *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoMsgTypes = {"_p_FIX__NoMsgTypes", "FIX::NoMsgTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested2PartyIDs = {"_p_FIX__NoNested2PartyIDs", "FIX::NoNested2PartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested2PartySubIDs = {"_p_FIX__NoNested2PartySubIDs", "FIX::NoNested2PartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested3PartyIDs = {"_p_FIX__NoNested3PartyIDs", "FIX::NoNested3PartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested3PartySubIDs = {"_p_FIX__NoNested3PartySubIDs", "FIX::NoNested3PartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested4PartyIDs = {"_p_FIX__NoNested4PartyIDs", "FIX::NoNested4PartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNested4PartySubIDs = {"_p_FIX__NoNested4PartySubIDs", "FIX::NoNested4PartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNestedInstrAttrib = {"_p_FIX__NoNestedInstrAttrib", "FIX::NoNestedInstrAttrib *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNestedPartyIDs = {"_p_FIX__NoNestedPartyIDs", "FIX::NoNestedPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNestedPartySubIDs = {"_p_FIX__NoNestedPartySubIDs", "FIX::NoNestedPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNewsRefIDs = {"_p_FIX__NoNewsRefIDs", "FIX::NoNewsRefIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoNotAffectedOrders = {"_p_FIX__NoNotAffectedOrders", "FIX::NoNotAffectedOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoOfLegUnderlyings = {"_p_FIX__NoOfLegUnderlyings", "FIX::NoOfLegUnderlyings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoOfSecSizes = {"_p_FIX__NoOfSecSizes", "FIX::NoOfSecSizes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoOrdTypeRules = {"_p_FIX__NoOrdTypeRules", "FIX::NoOrdTypeRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoOrders = {"_p_FIX__NoOrders", "FIX::NoOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPartyIDs = {"_p_FIX__NoPartyIDs", "FIX::NoPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPartySubIDs = {"_p_FIX__NoPartySubIDs", "FIX::NoPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPosAmt = {"_p_FIX__NoPosAmt", "FIX::NoPosAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoPositions = {"_p_FIX__NoPositions", "FIX::NoPositions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoQuoteEntries = {"_p_FIX__NoQuoteEntries", "FIX::NoQuoteEntries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoQuoteQualifiers = {"_p_FIX__NoQuoteQualifiers", "FIX::NoQuoteQualifiers *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoQuoteSets = {"_p_FIX__NoQuoteSets", "FIX::NoQuoteSets *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRateSources = {"_p_FIX__NoRateSources", "FIX::NoRateSources *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRegistDtls = {"_p_FIX__NoRegistDtls", "FIX::NoRegistDtls *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRelatedSym = {"_p_FIX__NoRelatedSym", "FIX::NoRelatedSym *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRootPartyIDs = {"_p_FIX__NoRootPartyIDs", "FIX::NoRootPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRootPartySubIDs = {"_p_FIX__NoRootPartySubIDs", "FIX::NoRootPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRoutingIDs = {"_p_FIX__NoRoutingIDs", "FIX::NoRoutingIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoRpts = {"_p_FIX__NoRpts", "FIX::NoRpts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSecurityAltID = {"_p_FIX__NoSecurityAltID", "FIX::NoSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSecurityTypes = {"_p_FIX__NoSecurityTypes", "FIX::NoSecurityTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlDetails = {"_p_FIX__NoSettlDetails", "FIX::NoSettlDetails *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlInst = {"_p_FIX__NoSettlInst", "FIX::NoSettlInst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlOblig = {"_p_FIX__NoSettlOblig", "FIX::NoSettlOblig *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlPartyIDs = {"_p_FIX__NoSettlPartyIDs", "FIX::NoSettlPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSettlPartySubIDs = {"_p_FIX__NoSettlPartySubIDs", "FIX::NoSettlPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSideTrdRegTS = {"_p_FIX__NoSideTrdRegTS", "FIX::NoSideTrdRegTS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoSides = {"_p_FIX__NoSides", "FIX::NoSides *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStatsIndicators = {"_p_FIX__NoStatsIndicators", "FIX::NoStatsIndicators *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStipulations = {"_p_FIX__NoStipulations", "FIX::NoStipulations *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStrategyParameters = {"_p_FIX__NoStrategyParameters", "FIX::NoStrategyParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStrikeRules = {"_p_FIX__NoStrikeRules", "FIX::NoStrikeRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoStrikes = {"_p_FIX__NoStrikes", "FIX::NoStrikes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTagValue = {"_p_FIX__NoTagValue", "FIX::NoTagValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTargetPartyIDs = {"_p_FIX__NoTargetPartyIDs", "FIX::NoTargetPartyIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTickRules = {"_p_FIX__NoTickRules", "FIX::NoTickRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTimeInForceRules = {"_p_FIX__NoTimeInForceRules", "FIX::NoTimeInForceRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTrades = {"_p_FIX__NoTrades", "FIX::NoTrades *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTradingSessionRules = {"_p_FIX__NoTradingSessionRules", "FIX::NoTradingSessionRules *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTradingSessions = {"_p_FIX__NoTradingSessions", "FIX::NoTradingSessions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTrdRegTimestamps = {"_p_FIX__NoTrdRegTimestamps", "FIX::NoTrdRegTimestamps *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoTrdRepIndicators = {"_p_FIX__NoTrdRepIndicators", "FIX::NoTrdRepIndicators *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyingAmounts = {"_p_FIX__NoUnderlyingAmounts", "FIX::NoUnderlyingAmounts *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyingLegSecurityAltID = {"_p_FIX__NoUnderlyingLegSecurityAltID", "FIX::NoUnderlyingLegSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyingSecurityAltID = {"_p_FIX__NoUnderlyingSecurityAltID", "FIX::NoUnderlyingSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyingStips = {"_p_FIX__NoUnderlyingStips", "FIX::NoUnderlyingStips *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUnderlyings = {"_p_FIX__NoUnderlyings", "FIX::NoUnderlyings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUndlyInstrumentParties = {"_p_FIX__NoUndlyInstrumentParties", "FIX::NoUndlyInstrumentParties *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NoUndlyInstrumentPartySubIDs = {"_p_FIX__NoUndlyInstrumentPartySubIDs", "FIX::NoUndlyInstrumentPartySubIDs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NotAffOrigClOrdID = {"_p_FIX__NotAffOrigClOrdID", "FIX::NotAffOrigClOrdID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NotAffectedOrderID = {"_p_FIX__NotAffectedOrderID", "FIX::NotAffectedOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NotifyBrokerOfCredit = {"_p_FIX__NotifyBrokerOfCredit", "FIX::NotifyBrokerOfCredit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NotionalPercentageOutstanding = {"_p_FIX__NotionalPercentageOutstanding", "FIX::NotionalPercentageOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NullApplication = {"_p_FIX__NullApplication", "FIX::NullApplication *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NullLog = {"_p_FIX__NullLog", "FIX::NullLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NumBidders = {"_p_FIX__NumBidders", "FIX::NumBidders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NumDaysInterest = {"_p_FIX__NumDaysInterest", "FIX::NumDaysInterest *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NumTickets = {"_p_FIX__NumTickets", "FIX::NumTickets *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__NumberOfOrders = {"_p_FIX__NumberOfOrders", "FIX::NumberOfOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OddLot = {"_p_FIX__OddLot", "FIX::OddLot *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferForwardPoints = {"_p_FIX__OfferForwardPoints", "FIX::OfferForwardPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferForwardPoints2 = {"_p_FIX__OfferForwardPoints2", "FIX::OfferForwardPoints2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferPx = {"_p_FIX__OfferPx", "FIX::OfferPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferSize = {"_p_FIX__OfferSize", "FIX::OfferSize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferSpotRate = {"_p_FIX__OfferSpotRate", "FIX::OfferSpotRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferSwapPoints = {"_p_FIX__OfferSwapPoints", "FIX::OfferSwapPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OfferYield = {"_p_FIX__OfferYield", "FIX::OfferYield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OnBehalfOfCompID = {"_p_FIX__OnBehalfOfCompID", "FIX::OnBehalfOfCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OnBehalfOfLocationID = {"_p_FIX__OnBehalfOfLocationID", "FIX::OnBehalfOfLocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OnBehalfOfSendingTime = {"_p_FIX__OnBehalfOfSendingTime", "FIX::OnBehalfOfSendingTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OnBehalfOfSubID = {"_p_FIX__OnBehalfOfSubID", "FIX::OnBehalfOfSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OpenClose = {"_p_FIX__OpenClose", "FIX::OpenClose *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OpenCloseSettlFlag = {"_p_FIX__OpenCloseSettlFlag", "FIX::OpenCloseSettlFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OpenCloseSettleFlag = {"_p_FIX__OpenCloseSettleFlag", "FIX::OpenCloseSettleFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OpenInterest = {"_p_FIX__OpenInterest", "FIX::OpenInterest *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OptAttribute = {"_p_FIX__OptAttribute", "FIX::OptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OptPayAmount = {"_p_FIX__OptPayAmount", "FIX::OptPayAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OptPayoutAmount = {"_p_FIX__OptPayoutAmount", "FIX::OptPayoutAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OptPayoutType = {"_p_FIX__OptPayoutType", "FIX::OptPayoutType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrdRejReason = {"_p_FIX__OrdRejReason", "FIX::OrdRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrdStatus = {"_p_FIX__OrdStatus", "FIX::OrdStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrdStatusReqID = {"_p_FIX__OrdStatusReqID", "FIX::OrdStatusReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrdType = {"_p_FIX__OrdType", "FIX::OrdType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderAvgPx = {"_p_FIX__OrderAvgPx", "FIX::OrderAvgPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderBookingQty = {"_p_FIX__OrderBookingQty", "FIX::OrderBookingQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderCapacity = {"_p_FIX__OrderCapacity", "FIX::OrderCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderCapacityQty = {"_p_FIX__OrderCapacityQty", "FIX::OrderCapacityQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderCategory = {"_p_FIX__OrderCategory", "FIX::OrderCategory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderDelay = {"_p_FIX__OrderDelay", "FIX::OrderDelay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderDelayUnit = {"_p_FIX__OrderDelayUnit", "FIX::OrderDelayUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderHandlingInstSource = {"_p_FIX__OrderHandlingInstSource", "FIX::OrderHandlingInstSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderID = {"_p_FIX__OrderID", "FIX::OrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderInputDevice = {"_p_FIX__OrderInputDevice", "FIX::OrderInputDevice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderPercent = {"_p_FIX__OrderPercent", "FIX::OrderPercent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderQty = {"_p_FIX__OrderQty", "FIX::OrderQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderQty2 = {"_p_FIX__OrderQty2", "FIX::OrderQty2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrderRestrictions = {"_p_FIX__OrderRestrictions", "FIX::OrderRestrictions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigClOrdID = {"_p_FIX__OrigClOrdID", "FIX::OrigClOrdID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigCrossID = {"_p_FIX__OrigCrossID", "FIX::OrigCrossID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigCustOrderCapacity = {"_p_FIX__OrigCustOrderCapacity", "FIX::OrigCustOrderCapacity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigOrdModTime = {"_p_FIX__OrigOrdModTime", "FIX::OrigOrdModTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigPosReqRefID = {"_p_FIX__OrigPosReqRefID", "FIX::OrigPosReqRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigSecondaryTradeID = {"_p_FIX__OrigSecondaryTradeID", "FIX::OrigSecondaryTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigSendingTime = {"_p_FIX__OrigSendingTime", "FIX::OrigSendingTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigTime = {"_p_FIX__OrigTime", "FIX::OrigTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigTradeDate = {"_p_FIX__OrigTradeDate", "FIX::OrigTradeDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigTradeHandlingInstr = {"_p_FIX__OrigTradeHandlingInstr", "FIX::OrigTradeHandlingInstr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OrigTradeID = {"_p_FIX__OrigTradeID", "FIX::OrigTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OriginalNotionalPercentageOutstanding = {"_p_FIX__OriginalNotionalPercentageOutstanding", "FIX::OriginalNotionalPercentageOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OutMainCntryUIndex = {"_p_FIX__OutMainCntryUIndex", "FIX::OutMainCntryUIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OutsideIndexPct = {"_p_FIX__OutsideIndexPct", "FIX::OutsideIndexPct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OwnerType = {"_p_FIX__OwnerType", "FIX::OwnerType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__OwnershipType = {"_p_FIX__OwnershipType", "FIX::OwnershipType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PERCENTAGE = {"_p_FIX__PERCENTAGE", "FIX::PERCENTAGE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PRICE = {"_p_FIX__PRICE", "FIX::PRICE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PRICEOFFSET = {"_p_FIX__PRICEOFFSET", "FIX::PRICEOFFSET *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ParentMktSegmID = {"_p_FIX__ParentMktSegmID", "FIX::ParentMktSegmID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ParticipationRate = {"_p_FIX__ParticipationRate", "FIX::ParticipationRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyID = {"_p_FIX__PartyID", "FIX::PartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyIDSource = {"_p_FIX__PartyIDSource", "FIX::PartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartyRole = {"_p_FIX__PartyRole", "FIX::PartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartySubID = {"_p_FIX__PartySubID", "FIX::PartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PartySubIDType = {"_p_FIX__PartySubIDType", "FIX::PartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Password = {"_p_FIX__Password", "FIX::Password *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PaymentDate = {"_p_FIX__PaymentDate", "FIX::PaymentDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PaymentMethod = {"_p_FIX__PaymentMethod", "FIX::PaymentMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PaymentRef = {"_p_FIX__PaymentRef", "FIX::PaymentRef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PaymentRemitterID = {"_p_FIX__PaymentRemitterID", "FIX::PaymentRemitterID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PctAtRisk = {"_p_FIX__PctAtRisk", "FIX::PctAtRisk *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegDifference = {"_p_FIX__PegDifference", "FIX::PegDifference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegLimitType = {"_p_FIX__PegLimitType", "FIX::PegLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegMoveType = {"_p_FIX__PegMoveType", "FIX::PegMoveType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegOffsetType = {"_p_FIX__PegOffsetType", "FIX::PegOffsetType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegOffsetValue = {"_p_FIX__PegOffsetValue", "FIX::PegOffsetValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegPriceType = {"_p_FIX__PegPriceType", "FIX::PegPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegRoundDirection = {"_p_FIX__PegRoundDirection", "FIX::PegRoundDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegScope = {"_p_FIX__PegScope", "FIX::PegScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegSecurityDesc = {"_p_FIX__PegSecurityDesc", "FIX::PegSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegSecurityID = {"_p_FIX__PegSecurityID", "FIX::PegSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegSecurityIDSource = {"_p_FIX__PegSecurityIDSource", "FIX::PegSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PegSymbol = {"_p_FIX__PegSymbol", "FIX::PegSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PeggedPrice = {"_p_FIX__PeggedPrice", "FIX::PeggedPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PeggedRefPrice = {"_p_FIX__PeggedRefPrice", "FIX::PeggedRefPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Pool = {"_p_FIX__Pool", "FIX::Pool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosAmt = {"_p_FIX__PosAmt", "FIX::PosAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosAmtType = {"_p_FIX__PosAmtType", "FIX::PosAmtType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintAction = {"_p_FIX__PosMaintAction", "FIX::PosMaintAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintResult = {"_p_FIX__PosMaintResult", "FIX::PosMaintResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintRptID = {"_p_FIX__PosMaintRptID", "FIX::PosMaintRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintRptRefID = {"_p_FIX__PosMaintRptRefID", "FIX::PosMaintRptRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosMaintStatus = {"_p_FIX__PosMaintStatus", "FIX::PosMaintStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosQtyStatus = {"_p_FIX__PosQtyStatus", "FIX::PosQtyStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosReqID = {"_p_FIX__PosReqID", "FIX::PosReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosReqResult = {"_p_FIX__PosReqResult", "FIX::PosReqResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosReqStatus = {"_p_FIX__PosReqStatus", "FIX::PosReqStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosReqType = {"_p_FIX__PosReqType", "FIX::PosReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosTransType = {"_p_FIX__PosTransType", "FIX::PosTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PosType = {"_p_FIX__PosType", "FIX::PosType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PositionCurrency = {"_p_FIX__PositionCurrency", "FIX::PositionCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PositionEffect = {"_p_FIX__PositionEffect", "FIX::PositionEffect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PositionLimit = {"_p_FIX__PositionLimit", "FIX::PositionLimit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PossDupFlag = {"_p_FIX__PossDupFlag", "FIX::PossDupFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PossResend = {"_p_FIX__PossResend", "FIX::PossResend *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PreTradeAnonymity = {"_p_FIX__PreTradeAnonymity", "FIX::PreTradeAnonymity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PreallocMethod = {"_p_FIX__PreallocMethod", "FIX::PreallocMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PrevClosePx = {"_p_FIX__PrevClosePx", "FIX::PrevClosePx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PreviouslyReported = {"_p_FIX__PreviouslyReported", "FIX::PreviouslyReported *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Price = {"_p_FIX__Price", "FIX::Price *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Price2 = {"_p_FIX__Price2", "FIX::Price2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceDelta = {"_p_FIX__PriceDelta", "FIX::PriceDelta *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceImprovement = {"_p_FIX__PriceImprovement", "FIX::PriceImprovement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceLimitType = {"_p_FIX__PriceLimitType", "FIX::PriceLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceProtectionScope = {"_p_FIX__PriceProtectionScope", "FIX::PriceProtectionScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceQuoteMethod = {"_p_FIX__PriceQuoteMethod", "FIX::PriceQuoteMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceType = {"_p_FIX__PriceType", "FIX::PriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceUnitOfMeasure = {"_p_FIX__PriceUnitOfMeasure", "FIX::PriceUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriceUnitOfMeasureQty = {"_p_FIX__PriceUnitOfMeasureQty", "FIX::PriceUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriorSettlPrice = {"_p_FIX__PriorSettlPrice", "FIX::PriorSettlPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriorSpreadIndicator = {"_p_FIX__PriorSpreadIndicator", "FIX::PriorSpreadIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PriorityIndicator = {"_p_FIX__PriorityIndicator", "FIX::PriorityIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PrivateQuote = {"_p_FIX__PrivateQuote", "FIX::PrivateQuote *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ProcessCode = {"_p_FIX__ProcessCode", "FIX::ProcessCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Product = {"_p_FIX__Product", "FIX::Product *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ProductComplex = {"_p_FIX__ProductComplex", "FIX::ProductComplex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ProgPeriodInterval = {"_p_FIX__ProgPeriodInterval", "FIX::ProgPeriodInterval *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ProgRptReqs = {"_p_FIX__ProgRptReqs", "FIX::ProgRptReqs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PublishTrdIndicator = {"_p_FIX__PublishTrdIndicator", "FIX::PublishTrdIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__PutOrCall = {"_p_FIX__PutOrCall", "FIX::PutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QTY = {"_p_FIX__QTY", "FIX::QTY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QtyType = {"_p_FIX__QtyType", "FIX::QtyType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Quantity = {"_p_FIX__Quantity", "FIX::Quantity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuantityDate = {"_p_FIX__QuantityDate", "FIX::QuantityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuantityType = {"_p_FIX__QuantityType", "FIX::QuantityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteAckStatus = {"_p_FIX__QuoteAckStatus", "FIX::QuoteAckStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteCancelType = {"_p_FIX__QuoteCancelType", "FIX::QuoteCancelType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteCondition = {"_p_FIX__QuoteCondition", "FIX::QuoteCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteEntryID = {"_p_FIX__QuoteEntryID", "FIX::QuoteEntryID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteEntryRejectReason = {"_p_FIX__QuoteEntryRejectReason", "FIX::QuoteEntryRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteEntryStatus = {"_p_FIX__QuoteEntryStatus", "FIX::QuoteEntryStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteID = {"_p_FIX__QuoteID", "FIX::QuoteID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteMsgID = {"_p_FIX__QuoteMsgID", "FIX::QuoteMsgID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuotePriceType = {"_p_FIX__QuotePriceType", "FIX::QuotePriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteQualifier = {"_p_FIX__QuoteQualifier", "FIX::QuoteQualifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRejectReason = {"_p_FIX__QuoteRejectReason", "FIX::QuoteRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteReqID = {"_p_FIX__QuoteReqID", "FIX::QuoteReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRequestRejectReason = {"_p_FIX__QuoteRequestRejectReason", "FIX::QuoteRequestRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRequestType = {"_p_FIX__QuoteRequestType", "FIX::QuoteRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRespID = {"_p_FIX__QuoteRespID", "FIX::QuoteRespID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteRespType = {"_p_FIX__QuoteRespType", "FIX::QuoteRespType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteResponseLevel = {"_p_FIX__QuoteResponseLevel", "FIX::QuoteResponseLevel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteSetID = {"_p_FIX__QuoteSetID", "FIX::QuoteSetID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteSetValidUntilTime = {"_p_FIX__QuoteSetValidUntilTime", "FIX::QuoteSetValidUntilTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteStatus = {"_p_FIX__QuoteStatus", "FIX::QuoteStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteStatusReqID = {"_p_FIX__QuoteStatusReqID", "FIX::QuoteStatusReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__QuoteType = {"_p_FIX__QuoteType", "FIX::QuoteType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RFQReqID = {"_p_FIX__RFQReqID", "FIX::RFQReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RateSource = {"_p_FIX__RateSource", "FIX::RateSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RateSourceType = {"_p_FIX__RateSourceType", "FIX::RateSourceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RatioQty = {"_p_FIX__RatioQty", "FIX::RatioQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RawData = {"_p_FIX__RawData", "FIX::RawData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RawDataLength = {"_p_FIX__RawDataLength", "FIX::RawDataLength *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReceivedDeptID = {"_p_FIX__ReceivedDeptID", "FIX::ReceivedDeptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RedemptionDate = {"_p_FIX__RedemptionDate", "FIX::RedemptionDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefAllocID = {"_p_FIX__RefAllocID", "FIX::RefAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplExtID = {"_p_FIX__RefApplExtID", "FIX::RefApplExtID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplID = {"_p_FIX__RefApplID", "FIX::RefApplID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplLastSeqNum = {"_p_FIX__RefApplLastSeqNum", "FIX::RefApplLastSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplReqID = {"_p_FIX__RefApplReqID", "FIX::RefApplReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefApplVerID = {"_p_FIX__RefApplVerID", "FIX::RefApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefCompID = {"_p_FIX__RefCompID", "FIX::RefCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefCstmApplVerID = {"_p_FIX__RefCstmApplVerID", "FIX::RefCstmApplVerID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefMsgType = {"_p_FIX__RefMsgType", "FIX::RefMsgType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefOrdIDReason = {"_p_FIX__RefOrdIDReason", "FIX::RefOrdIDReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefOrderID = {"_p_FIX__RefOrderID", "FIX::RefOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefOrderIDSource = {"_p_FIX__RefOrderIDSource", "FIX::RefOrderIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefSeqNum = {"_p_FIX__RefSeqNum", "FIX::RefSeqNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefSubID = {"_p_FIX__RefSubID", "FIX::RefSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefTagID = {"_p_FIX__RefTagID", "FIX::RefTagID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReferencePage = {"_p_FIX__ReferencePage", "FIX::ReferencePage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefreshIndicator = {"_p_FIX__RefreshIndicator", "FIX::RefreshIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RefreshQty = {"_p_FIX__RefreshQty", "FIX::RefreshQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistAcctType = {"_p_FIX__RegistAcctType", "FIX::RegistAcctType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistDetls = {"_p_FIX__RegistDetls", "FIX::RegistDetls *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistDtls = {"_p_FIX__RegistDtls", "FIX::RegistDtls *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistEmail = {"_p_FIX__RegistEmail", "FIX::RegistEmail *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistID = {"_p_FIX__RegistID", "FIX::RegistID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistRefID = {"_p_FIX__RegistRefID", "FIX::RegistRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistRejReasonCode = {"_p_FIX__RegistRejReasonCode", "FIX::RegistRejReasonCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistRejReasonText = {"_p_FIX__RegistRejReasonText", "FIX::RegistRejReasonText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistStatus = {"_p_FIX__RegistStatus", "FIX::RegistStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RegistTransType = {"_p_FIX__RegistTransType", "FIX::RegistTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RejectLogon = {"_p_FIX__RejectLogon", "FIX::RejectLogon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RejectText = {"_p_FIX__RejectText", "FIX::RejectText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelSymTransactTime = {"_p_FIX__RelSymTransactTime", "FIX::RelSymTransactTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RelatdSym = {"_p_FIX__RelatdSym", "FIX::RelatdSym *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepeatedTag = {"_p_FIX__RepeatedTag", "FIX::RepeatedTag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepeatingGroupCountMismatch = {"_p_FIX__RepeatingGroupCountMismatch", "FIX::RepeatingGroupCountMismatch *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepoCollateralSecurityType = {"_p_FIX__RepoCollateralSecurityType", "FIX::RepoCollateralSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReportToExch = {"_p_FIX__ReportToExch", "FIX::ReportToExch *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReportedPx = {"_p_FIX__ReportedPx", "FIX::ReportedPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReportedPxDiff = {"_p_FIX__ReportedPxDiff", "FIX::ReportedPxDiff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepurchaseRate = {"_p_FIX__RepurchaseRate", "FIX::RepurchaseRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RepurchaseTerm = {"_p_FIX__RepurchaseTerm", "FIX::RepurchaseTerm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RequiredTagMissing = {"_p_FIX__RequiredTagMissing", "FIX::RequiredTagMissing *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ResetSeqNumFlag = {"_p_FIX__ResetSeqNumFlag", "FIX::ResetSeqNumFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RespondentType = {"_p_FIX__RespondentType", "FIX::RespondentType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ResponseDestination = {"_p_FIX__ResponseDestination", "FIX::ResponseDestination *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ResponseTransportType = {"_p_FIX__ResponseTransportType", "FIX::ResponseTransportType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RestructuringType = {"_p_FIX__RestructuringType", "FIX::RestructuringType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ReversalIndicator = {"_p_FIX__ReversalIndicator", "FIX::ReversalIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RiskFreeRate = {"_p_FIX__RiskFreeRate", "FIX::RiskFreeRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RndPx = {"_p_FIX__RndPx", "FIX::RndPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartyID = {"_p_FIX__RootPartyID", "FIX::RootPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartyIDSource = {"_p_FIX__RootPartyIDSource", "FIX::RootPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartyRole = {"_p_FIX__RootPartyRole", "FIX::RootPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartySubID = {"_p_FIX__RootPartySubID", "FIX::RootPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RootPartySubIDType = {"_p_FIX__RootPartySubIDType", "FIX::RootPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoundLot = {"_p_FIX__RoundLot", "FIX::RoundLot *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoundingDirection = {"_p_FIX__RoundingDirection", "FIX::RoundingDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoundingModulus = {"_p_FIX__RoundingModulus", "FIX::RoundingModulus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoutingID = {"_p_FIX__RoutingID", "FIX::RoutingID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RoutingType = {"_p_FIX__RoutingType", "FIX::RoutingType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RptSeq = {"_p_FIX__RptSeq", "FIX::RptSeq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RptSys = {"_p_FIX__RptSys", "FIX::RptSys *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Rule80A = {"_p_FIX__Rule80A", "FIX::Rule80A *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__RuntimeError = {"_p_FIX__RuntimeError", "FIX::RuntimeError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SEQNUM = {"_p_FIX__SEQNUM", "FIX::SEQNUM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__STRING = {"_p_FIX__STRING", "FIX::STRING *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Scope = {"_p_FIX__Scope", "FIX::Scope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ScreenLog = {"_p_FIX__ScreenLog", "FIX::ScreenLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ScreenLogFactory = {"_p_FIX__ScreenLogFactory", "FIX::ScreenLogFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryAllocID = {"_p_FIX__SecondaryAllocID", "FIX::SecondaryAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryClOrdID = {"_p_FIX__SecondaryClOrdID", "FIX::SecondaryClOrdID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryDisplayQty = {"_p_FIX__SecondaryDisplayQty", "FIX::SecondaryDisplayQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryExecID = {"_p_FIX__SecondaryExecID", "FIX::SecondaryExecID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryFirmTradeID = {"_p_FIX__SecondaryFirmTradeID", "FIX::SecondaryFirmTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryHighLimitPrice = {"_p_FIX__SecondaryHighLimitPrice", "FIX::SecondaryHighLimitPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryIndividualAllocID = {"_p_FIX__SecondaryIndividualAllocID", "FIX::SecondaryIndividualAllocID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryLowLimitPrice = {"_p_FIX__SecondaryLowLimitPrice", "FIX::SecondaryLowLimitPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryOrderID = {"_p_FIX__SecondaryOrderID", "FIX::SecondaryOrderID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryPriceLimitType = {"_p_FIX__SecondaryPriceLimitType", "FIX::SecondaryPriceLimitType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTradeID = {"_p_FIX__SecondaryTradeID", "FIX::SecondaryTradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTradeReportID = {"_p_FIX__SecondaryTradeReportID", "FIX::SecondaryTradeReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTradeReportRefID = {"_p_FIX__SecondaryTradeReportRefID", "FIX::SecondaryTradeReportRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTradingReferencePrice = {"_p_FIX__SecondaryTradingReferencePrice", "FIX::SecondaryTradingReferencePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecondaryTrdType = {"_p_FIX__SecondaryTrdType", "FIX::SecondaryTrdType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecureData = {"_p_FIX__SecureData", "FIX::SecureData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecureDataLen = {"_p_FIX__SecureDataLen", "FIX::SecureDataLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityAltID = {"_p_FIX__SecurityAltID", "FIX::SecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityAltIDSource = {"_p_FIX__SecurityAltIDSource", "FIX::SecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityDesc = {"_p_FIX__SecurityDesc", "FIX::SecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityExchange = {"_p_FIX__SecurityExchange", "FIX::SecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityGroup = {"_p_FIX__SecurityGroup", "FIX::SecurityGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityID = {"_p_FIX__SecurityID", "FIX::SecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityIDSource = {"_p_FIX__SecurityIDSource", "FIX::SecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListDesc = {"_p_FIX__SecurityListDesc", "FIX::SecurityListDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListID = {"_p_FIX__SecurityListID", "FIX::SecurityListID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListRefID = {"_p_FIX__SecurityListRefID", "FIX::SecurityListRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListRequestType = {"_p_FIX__SecurityListRequestType", "FIX::SecurityListRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListType = {"_p_FIX__SecurityListType", "FIX::SecurityListType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityListTypeSource = {"_p_FIX__SecurityListTypeSource", "FIX::SecurityListTypeSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityReportID = {"_p_FIX__SecurityReportID", "FIX::SecurityReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityReqID = {"_p_FIX__SecurityReqID", "FIX::SecurityReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityRequestResult = {"_p_FIX__SecurityRequestResult", "FIX::SecurityRequestResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityRequestType = {"_p_FIX__SecurityRequestType", "FIX::SecurityRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityResponseID = {"_p_FIX__SecurityResponseID", "FIX::SecurityResponseID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityResponseType = {"_p_FIX__SecurityResponseType", "FIX::SecurityResponseType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentAcctName = {"_p_FIX__SecuritySettlAgentAcctName", "FIX::SecuritySettlAgentAcctName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentAcctNum = {"_p_FIX__SecuritySettlAgentAcctNum", "FIX::SecuritySettlAgentAcctNum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentCode = {"_p_FIX__SecuritySettlAgentCode", "FIX::SecuritySettlAgentCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentContactName = {"_p_FIX__SecuritySettlAgentContactName", "FIX::SecuritySettlAgentContactName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentContactPhone = {"_p_FIX__SecuritySettlAgentContactPhone", "FIX::SecuritySettlAgentContactPhone *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySettlAgentName = {"_p_FIX__SecuritySettlAgentName", "FIX::SecuritySettlAgentName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityStatus = {"_p_FIX__SecurityStatus", "FIX::SecurityStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityStatusReqID = {"_p_FIX__SecurityStatusReqID", "FIX::SecurityStatusReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecuritySubType = {"_p_FIX__SecuritySubType", "FIX::SecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityTradingEvent = {"_p_FIX__SecurityTradingEvent", "FIX::SecurityTradingEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityTradingStatus = {"_p_FIX__SecurityTradingStatus", "FIX::SecurityTradingStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityType = {"_p_FIX__SecurityType", "FIX::SecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityUpdateAction = {"_p_FIX__SecurityUpdateAction", "FIX::SecurityUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityXML = {"_p_FIX__SecurityXML", "FIX::SecurityXML *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityXMLLen = {"_p_FIX__SecurityXMLLen", "FIX::SecurityXMLLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SecurityXMLSchema = {"_p_FIX__SecurityXMLSchema", "FIX::SecurityXMLSchema *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SellVolume = {"_p_FIX__SellVolume", "FIX::SellVolume *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SellerDays = {"_p_FIX__SellerDays", "FIX::SellerDays *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SenderCompID = {"_p_FIX__SenderCompID", "FIX::SenderCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SenderLocationID = {"_p_FIX__SenderLocationID", "FIX::SenderLocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SenderSubID = {"_p_FIX__SenderSubID", "FIX::SenderSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SendingDate = {"_p_FIX__SendingDate", "FIX::SendingDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SendingTime = {"_p_FIX__SendingTime", "FIX::SendingTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Seniority = {"_p_FIX__Seniority", "FIX::Seniority *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Session = {"_p_FIX__Session", "FIX::Session *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionID = {"_p_FIX__SessionID", "FIX::SessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionNotFound = {"_p_FIX__SessionNotFound", "FIX::SessionNotFound *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionRejectReason = {"_p_FIX__SessionRejectReason", "FIX::SessionRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionSettings = {"_p_FIX__SessionSettings", "FIX::SessionSettings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SessionStatus = {"_p_FIX__SessionStatus", "FIX::SessionStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlBrkrCode = {"_p_FIX__SettlBrkrCode", "FIX::SettlBrkrCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrAmt = {"_p_FIX__SettlCurrAmt", "FIX::SettlCurrAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrBidFxRate = {"_p_FIX__SettlCurrBidFxRate", "FIX::SettlCurrBidFxRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrFxRate = {"_p_FIX__SettlCurrFxRate", "FIX::SettlCurrFxRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrFxRateCalc = {"_p_FIX__SettlCurrFxRateCalc", "FIX::SettlCurrFxRateCalc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrOfferFxRate = {"_p_FIX__SettlCurrOfferFxRate", "FIX::SettlCurrOfferFxRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlCurrency = {"_p_FIX__SettlCurrency", "FIX::SettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlDate = {"_p_FIX__SettlDate", "FIX::SettlDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlDate2 = {"_p_FIX__SettlDate2", "FIX::SettlDate2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlDeliveryType = {"_p_FIX__SettlDeliveryType", "FIX::SettlDeliveryType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlDepositoryCode = {"_p_FIX__SettlDepositoryCode", "FIX::SettlDepositoryCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstCode = {"_p_FIX__SettlInstCode", "FIX::SettlInstCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstID = {"_p_FIX__SettlInstID", "FIX::SettlInstID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstMode = {"_p_FIX__SettlInstMode", "FIX::SettlInstMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstMsgID = {"_p_FIX__SettlInstMsgID", "FIX::SettlInstMsgID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstRefID = {"_p_FIX__SettlInstRefID", "FIX::SettlInstRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstReqID = {"_p_FIX__SettlInstReqID", "FIX::SettlInstReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstReqRejCode = {"_p_FIX__SettlInstReqRejCode", "FIX::SettlInstReqRejCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstSource = {"_p_FIX__SettlInstSource", "FIX::SettlInstSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlInstTransType = {"_p_FIX__SettlInstTransType", "FIX::SettlInstTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlLocation = {"_p_FIX__SettlLocation", "FIX::SettlLocation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlMethod = {"_p_FIX__SettlMethod", "FIX::SettlMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligID = {"_p_FIX__SettlObligID", "FIX::SettlObligID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligMode = {"_p_FIX__SettlObligMode", "FIX::SettlObligMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligMsgID = {"_p_FIX__SettlObligMsgID", "FIX::SettlObligMsgID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligRefID = {"_p_FIX__SettlObligRefID", "FIX::SettlObligRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligSource = {"_p_FIX__SettlObligSource", "FIX::SettlObligSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlObligTransType = {"_p_FIX__SettlObligTransType", "FIX::SettlObligTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartyID = {"_p_FIX__SettlPartyID", "FIX::SettlPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartyIDSource = {"_p_FIX__SettlPartyIDSource", "FIX::SettlPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartyRole = {"_p_FIX__SettlPartyRole", "FIX::SettlPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartySubID = {"_p_FIX__SettlPartySubID", "FIX::SettlPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPartySubIDType = {"_p_FIX__SettlPartySubIDType", "FIX::SettlPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPrice = {"_p_FIX__SettlPrice", "FIX::SettlPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlPriceType = {"_p_FIX__SettlPriceType", "FIX::SettlPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlSessID = {"_p_FIX__SettlSessID", "FIX::SettlSessID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlSessSubID = {"_p_FIX__SettlSessSubID", "FIX::SettlSessSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlType = {"_p_FIX__SettlType", "FIX::SettlType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettleOnOpenFlag = {"_p_FIX__SettleOnOpenFlag", "FIX::SettleOnOpenFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlementCycleNo = {"_p_FIX__SettlementCycleNo", "FIX::SettlementCycleNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SettlmntTyp = {"_p_FIX__SettlmntTyp", "FIX::SettlmntTyp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SharedCommission = {"_p_FIX__SharedCommission", "FIX::SharedCommission *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Shares = {"_p_FIX__Shares", "FIX::Shares *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ShortQty = {"_p_FIX__ShortQty", "FIX::ShortQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ShortSaleReason = {"_p_FIX__ShortSaleReason", "FIX::ShortSaleReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Side = {"_p_FIX__Side", "FIX::Side *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideComplianceID = {"_p_FIX__SideComplianceID", "FIX::SideComplianceID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideCurrency = {"_p_FIX__SideCurrency", "FIX::SideCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideExecID = {"_p_FIX__SideExecID", "FIX::SideExecID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideFillStationCd = {"_p_FIX__SideFillStationCd", "FIX::SideFillStationCd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideGrossTradeAmt = {"_p_FIX__SideGrossTradeAmt", "FIX::SideGrossTradeAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideLastQty = {"_p_FIX__SideLastQty", "FIX::SideLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideLiquidityInd = {"_p_FIX__SideLiquidityInd", "FIX::SideLiquidityInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideMultiLegReportingType = {"_p_FIX__SideMultiLegReportingType", "FIX::SideMultiLegReportingType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideQty = {"_p_FIX__SideQty", "FIX::SideQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideReasonCd = {"_p_FIX__SideReasonCd", "FIX::SideReasonCd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideSettlCurrency = {"_p_FIX__SideSettlCurrency", "FIX::SideSettlCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTimeInForce = {"_p_FIX__SideTimeInForce", "FIX::SideTimeInForce *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTradeReportID = {"_p_FIX__SideTradeReportID", "FIX::SideTradeReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTrdRegTimestamp = {"_p_FIX__SideTrdRegTimestamp", "FIX::SideTrdRegTimestamp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTrdRegTimestampSrc = {"_p_FIX__SideTrdRegTimestampSrc", "FIX::SideTrdRegTimestampSrc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTrdRegTimestampType = {"_p_FIX__SideTrdRegTimestampType", "FIX::SideTrdRegTimestampType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideTrdSubTyp = {"_p_FIX__SideTrdSubTyp", "FIX::SideTrdSubTyp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideValue1 = {"_p_FIX__SideValue1", "FIX::SideValue1 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideValue2 = {"_p_FIX__SideValue2", "FIX::SideValue2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SideValueInd = {"_p_FIX__SideValueInd", "FIX::SideValueInd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Signature = {"_p_FIX__Signature", "FIX::Signature *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SignatureLength = {"_p_FIX__SignatureLength", "FIX::SignatureLength *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketAcceptor = {"_p_FIX__SocketAcceptor", "FIX::SocketAcceptor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketCloseFailed = {"_p_FIX__SocketCloseFailed", "FIX::SocketCloseFailed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketException = {"_p_FIX__SocketException", "FIX::SocketException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketInitiator = {"_p_FIX__SocketInitiator", "FIX::SocketInitiator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketRecvFailed = {"_p_FIX__SocketRecvFailed", "FIX::SocketRecvFailed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SocketSendFailed = {"_p_FIX__SocketSendFailed", "FIX::SocketSendFailed *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SolicitedFlag = {"_p_FIX__SolicitedFlag", "FIX::SolicitedFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Spread = {"_p_FIX__Spread", "FIX::Spread *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SpreadToBenchmark = {"_p_FIX__SpreadToBenchmark", "FIX::SpreadToBenchmark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StandInstDbID = {"_p_FIX__StandInstDbID", "FIX::StandInstDbID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StandInstDbName = {"_p_FIX__StandInstDbName", "FIX::StandInstDbName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StandInstDbType = {"_p_FIX__StandInstDbType", "FIX::StandInstDbType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartCash = {"_p_FIX__StartCash", "FIX::StartCash *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartDate = {"_p_FIX__StartDate", "FIX::StartDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartMaturityMonthYear = {"_p_FIX__StartMaturityMonthYear", "FIX::StartMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartStrikePxRange = {"_p_FIX__StartStrikePxRange", "FIX::StartStrikePxRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StartTickPriceRange = {"_p_FIX__StartTickPriceRange", "FIX::StartTickPriceRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StateOrProvinceOfIssue = {"_p_FIX__StateOrProvinceOfIssue", "FIX::StateOrProvinceOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StatsType = {"_p_FIX__StatsType", "FIX::StatsType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StatusText = {"_p_FIX__StatusText", "FIX::StatusText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StatusValue = {"_p_FIX__StatusValue", "FIX::StatusValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StipulationType = {"_p_FIX__StipulationType", "FIX::StipulationType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StipulationValue = {"_p_FIX__StipulationValue", "FIX::StipulationValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StopPx = {"_p_FIX__StopPx", "FIX::StopPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrategyParameterName = {"_p_FIX__StrategyParameterName", "FIX::StrategyParameterName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrategyParameterType = {"_p_FIX__StrategyParameterType", "FIX::StrategyParameterType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrategyParameterValue = {"_p_FIX__StrategyParameterValue", "FIX::StrategyParameterValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnAckType = {"_p_FIX__StreamAsgnAckType", "FIX::StreamAsgnAckType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnRejReason = {"_p_FIX__StreamAsgnRejReason", "FIX::StreamAsgnRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnReqID = {"_p_FIX__StreamAsgnReqID", "FIX::StreamAsgnReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnReqType = {"_p_FIX__StreamAsgnReqType", "FIX::StreamAsgnReqType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnRptID = {"_p_FIX__StreamAsgnRptID", "FIX::StreamAsgnRptID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StreamAsgnType = {"_p_FIX__StreamAsgnType", "FIX::StreamAsgnType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeCurrency = {"_p_FIX__StrikeCurrency", "FIX::StrikeCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeExerciseStyle = {"_p_FIX__StrikeExerciseStyle", "FIX::StrikeExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeIncrement = {"_p_FIX__StrikeIncrement", "FIX::StrikeIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeMultiplier = {"_p_FIX__StrikeMultiplier", "FIX::StrikeMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikePrice = {"_p_FIX__StrikePrice", "FIX::StrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikePriceBoundaryMethod = {"_p_FIX__StrikePriceBoundaryMethod", "FIX::StrikePriceBoundaryMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikePriceBoundaryPrecision = {"_p_FIX__StrikePriceBoundaryPrecision", "FIX::StrikePriceBoundaryPrecision *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikePriceDeterminationMethod = {"_p_FIX__StrikePriceDeterminationMethod", "FIX::StrikePriceDeterminationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeRuleID = {"_p_FIX__StrikeRuleID", "FIX::StrikeRuleID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeTime = {"_p_FIX__StrikeTime", "FIX::StrikeTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StrikeValue = {"_p_FIX__StrikeValue", "FIX::StrikeValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__StringField = {"_p_FIX__StringField", "FIX::LocalMktDateField *|FIX::MonthYearField *|FIX::CurrencyField *|FIX::DataField *|FIX::TzTimeStampField *|FIX::CountryField *|FIX::TzTimeOnlyField *|FIX::MonthField *|FIX::DayOfMonthField *|FIX::MultipleValueStringField *|FIX::MultipleStringValueField *|FIX::MultipleCharValueField *|FIX::ExchangeField *|FIX::StringField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Subject = {"_p_FIX__Subject", "FIX::Subject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SubscriptionRequestType = {"_p_FIX__SubscriptionRequestType", "FIX::SubscriptionRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SwapPoints = {"_p_FIX__SwapPoints", "FIX::SwapPoints *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Symbol = {"_p_FIX__Symbol", "FIX::Symbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SymbolSfx = {"_p_FIX__SymbolSfx", "FIX::SymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__SynchronizedApplication = {"_p_FIX__SynchronizedApplication", "FIX::SynchronizedApplication *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TYPE__Type = {"_p_FIX__TYPE__Type", "FIX::TYPE::Type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TZTIMEONLY = {"_p_FIX__TZTIMEONLY", "FIX::TZTIMEONLY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TZTIMESTAMP = {"_p_FIX__TZTIMESTAMP", "FIX::TZTIMESTAMP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TZTransactTime = {"_p_FIX__TZTransactTime", "FIX::TZTransactTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TagNotDefinedForMessage = {"_p_FIX__TagNotDefinedForMessage", "FIX::TagNotDefinedForMessage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TagOutOfOrder = {"_p_FIX__TagOutOfOrder", "FIX::TagOutOfOrder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetCompID = {"_p_FIX__TargetCompID", "FIX::TargetCompID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetLocationID = {"_p_FIX__TargetLocationID", "FIX::TargetLocationID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetPartyID = {"_p_FIX__TargetPartyID", "FIX::TargetPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetPartyIDSource = {"_p_FIX__TargetPartyIDSource", "FIX::TargetPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetPartyRole = {"_p_FIX__TargetPartyRole", "FIX::TargetPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetStrategy = {"_p_FIX__TargetStrategy", "FIX::TargetStrategy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetStrategyParameters = {"_p_FIX__TargetStrategyParameters", "FIX::TargetStrategyParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetStrategyPerformance = {"_p_FIX__TargetStrategyPerformance", "FIX::TargetStrategyPerformance *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TargetSubID = {"_p_FIX__TargetSubID", "FIX::TargetSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TaxAdvantageType = {"_p_FIX__TaxAdvantageType", "FIX::TaxAdvantageType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TerminationType = {"_p_FIX__TerminationType", "FIX::TerminationType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TestMessageIndicator = {"_p_FIX__TestMessageIndicator", "FIX::TestMessageIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TestReqID = {"_p_FIX__TestReqID", "FIX::TestReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Text = {"_p_FIX__Text", "FIX::Text *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ThresholdAmount = {"_p_FIX__ThresholdAmount", "FIX::ThresholdAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TickDirection = {"_p_FIX__TickDirection", "FIX::TickDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TickIncrement = {"_p_FIX__TickIncrement", "FIX::TickIncrement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TickRuleType = {"_p_FIX__TickRuleType", "FIX::TickRuleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TierCode = {"_p_FIX__TierCode", "FIX::TierCode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TimeBracket = {"_p_FIX__TimeBracket", "FIX::TimeBracket *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TimeInForce = {"_p_FIX__TimeInForce", "FIX::TimeInForce *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TimeToExpiration = {"_p_FIX__TimeToExpiration", "FIX::TimeToExpiration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TimeUnit = {"_p_FIX__TimeUnit", "FIX::TimeUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoAccQuotes = {"_p_FIX__TotNoAccQuotes", "FIX::TotNoAccQuotes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoAllocs = {"_p_FIX__TotNoAllocs", "FIX::TotNoAllocs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoCxldQuotes = {"_p_FIX__TotNoCxldQuotes", "FIX::TotNoCxldQuotes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoFills = {"_p_FIX__TotNoFills", "FIX::TotNoFills *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoOrders = {"_p_FIX__TotNoOrders", "FIX::TotNoOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoQuoteEntries = {"_p_FIX__TotNoQuoteEntries", "FIX::TotNoQuoteEntries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoRejQuotes = {"_p_FIX__TotNoRejQuotes", "FIX::TotNoRejQuotes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoRelatedSym = {"_p_FIX__TotNoRelatedSym", "FIX::TotNoRelatedSym *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoSecurityTypes = {"_p_FIX__TotNoSecurityTypes", "FIX::TotNoSecurityTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNoStrikes = {"_p_FIX__TotNoStrikes", "FIX::TotNoStrikes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNumAssignmentReports = {"_p_FIX__TotNumAssignmentReports", "FIX::TotNumAssignmentReports *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNumReports = {"_p_FIX__TotNumReports", "FIX::TotNumReports *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotNumTradeReports = {"_p_FIX__TotNumTradeReports", "FIX::TotNumTradeReports *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotQuoteEntries = {"_p_FIX__TotQuoteEntries", "FIX::TotQuoteEntries *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalAccruedInterestAmt = {"_p_FIX__TotalAccruedInterestAmt", "FIX::TotalAccruedInterestAmt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalAffectedOrders = {"_p_FIX__TotalAffectedOrders", "FIX::TotalAffectedOrders *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalNetValue = {"_p_FIX__TotalNetValue", "FIX::TotalNetValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalNumPosReports = {"_p_FIX__TotalNumPosReports", "FIX::TotalNumPosReports *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalNumSecurities = {"_p_FIX__TotalNumSecurities", "FIX::TotalNumSecurities *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalNumSecurityTypes = {"_p_FIX__TotalNumSecurityTypes", "FIX::TotalNumSecurityTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalTakedown = {"_p_FIX__TotalTakedown", "FIX::TotalTakedown *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalVolumeTraded = {"_p_FIX__TotalVolumeTraded", "FIX::TotalVolumeTraded *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalVolumeTradedDate = {"_p_FIX__TotalVolumeTradedDate", "FIX::TotalVolumeTradedDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TotalVolumeTradedTime = {"_p_FIX__TotalVolumeTradedTime", "FIX::TotalVolumeTradedTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesCloseTime = {"_p_FIX__TradSesCloseTime", "FIX::TradSesCloseTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesEndTime = {"_p_FIX__TradSesEndTime", "FIX::TradSesEndTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesEvent = {"_p_FIX__TradSesEvent", "FIX::TradSesEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesMethod = {"_p_FIX__TradSesMethod", "FIX::TradSesMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesMode = {"_p_FIX__TradSesMode", "FIX::TradSesMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesOpenTime = {"_p_FIX__TradSesOpenTime", "FIX::TradSesOpenTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesPreCloseTime = {"_p_FIX__TradSesPreCloseTime", "FIX::TradSesPreCloseTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesReqID = {"_p_FIX__TradSesReqID", "FIX::TradSesReqID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesStartTime = {"_p_FIX__TradSesStartTime", "FIX::TradSesStartTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesStatus = {"_p_FIX__TradSesStatus", "FIX::TradSesStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesStatusRejReason = {"_p_FIX__TradSesStatusRejReason", "FIX::TradSesStatusRejReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradSesUpdateAction = {"_p_FIX__TradSesUpdateAction", "FIX::TradSesUpdateAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeAllocIndicator = {"_p_FIX__TradeAllocIndicator", "FIX::TradeAllocIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeCondition = {"_p_FIX__TradeCondition", "FIX::TradeCondition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeDate = {"_p_FIX__TradeDate", "FIX::TradeDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeHandlingInstr = {"_p_FIX__TradeHandlingInstr", "FIX::TradeHandlingInstr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeID = {"_p_FIX__TradeID", "FIX::TradeID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeInputDevice = {"_p_FIX__TradeInputDevice", "FIX::TradeInputDevice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeInputSource = {"_p_FIX__TradeInputSource", "FIX::TradeInputSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeLegRefID = {"_p_FIX__TradeLegRefID", "FIX::TradeLegRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeLinkID = {"_p_FIX__TradeLinkID", "FIX::TradeLinkID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeOriginationDate = {"_p_FIX__TradeOriginationDate", "FIX::TradeOriginationDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradePublishIndicator = {"_p_FIX__TradePublishIndicator", "FIX::TradePublishIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportID = {"_p_FIX__TradeReportID", "FIX::TradeReportID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportRefID = {"_p_FIX__TradeReportRefID", "FIX::TradeReportRefID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportRejectReason = {"_p_FIX__TradeReportRejectReason", "FIX::TradeReportRejectReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportTransType = {"_p_FIX__TradeReportTransType", "FIX::TradeReportTransType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeReportType = {"_p_FIX__TradeReportType", "FIX::TradeReportType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeRequestID = {"_p_FIX__TradeRequestID", "FIX::TradeRequestID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeRequestResult = {"_p_FIX__TradeRequestResult", "FIX::TradeRequestResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeRequestStatus = {"_p_FIX__TradeRequestStatus", "FIX::TradeRequestStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeRequestType = {"_p_FIX__TradeRequestType", "FIX::TradeRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeType = {"_p_FIX__TradeType", "FIX::TradeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradeVolume = {"_p_FIX__TradeVolume", "FIX::TradeVolume *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradedFlatSwitch = {"_p_FIX__TradedFlatSwitch", "FIX::TradedFlatSwitch *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingCurrency = {"_p_FIX__TradingCurrency", "FIX::TradingCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingReferencePrice = {"_p_FIX__TradingReferencePrice", "FIX::TradingReferencePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingSessionDesc = {"_p_FIX__TradingSessionDesc", "FIX::TradingSessionDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingSessionID = {"_p_FIX__TradingSessionID", "FIX::TradingSessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TradingSessionSubID = {"_p_FIX__TradingSessionSubID", "FIX::TradingSessionSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Trailer = {"_p_FIX__Trailer", "FIX::Trailer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TransBkdTime = {"_p_FIX__TransBkdTime", "FIX::TransBkdTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TransactTime = {"_p_FIX__TransactTime", "FIX::TransactTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TransferReason = {"_p_FIX__TransferReason", "FIX::TransferReason *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdMatchID = {"_p_FIX__TrdMatchID", "FIX::TrdMatchID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRegTimestamp = {"_p_FIX__TrdRegTimestamp", "FIX::TrdRegTimestamp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRegTimestampOrigin = {"_p_FIX__TrdRegTimestampOrigin", "FIX::TrdRegTimestampOrigin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRegTimestampType = {"_p_FIX__TrdRegTimestampType", "FIX::TrdRegTimestampType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRepIndicator = {"_p_FIX__TrdRepIndicator", "FIX::TrdRepIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRepPartyRole = {"_p_FIX__TrdRepPartyRole", "FIX::TrdRepPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdRptStatus = {"_p_FIX__TrdRptStatus", "FIX::TrdRptStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdSubType = {"_p_FIX__TrdSubType", "FIX::TrdSubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TrdType = {"_p_FIX__TrdType", "FIX::TrdType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerAction = {"_p_FIX__TriggerAction", "FIX::TriggerAction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerNewPrice = {"_p_FIX__TriggerNewPrice", "FIX::TriggerNewPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerNewQty = {"_p_FIX__TriggerNewQty", "FIX::TriggerNewQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerOrderType = {"_p_FIX__TriggerOrderType", "FIX::TriggerOrderType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerPrice = {"_p_FIX__TriggerPrice", "FIX::TriggerPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerPriceDirection = {"_p_FIX__TriggerPriceDirection", "FIX::TriggerPriceDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerPriceType = {"_p_FIX__TriggerPriceType", "FIX::TriggerPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerPriceTypeScope = {"_p_FIX__TriggerPriceTypeScope", "FIX::TriggerPriceTypeScope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerSecurityDesc = {"_p_FIX__TriggerSecurityDesc", "FIX::TriggerSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerSecurityID = {"_p_FIX__TriggerSecurityID", "FIX::TriggerSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerSecurityIDSource = {"_p_FIX__TriggerSecurityIDSource", "FIX::TriggerSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerSymbol = {"_p_FIX__TriggerSymbol", "FIX::TriggerSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerTradingSessionID = {"_p_FIX__TriggerTradingSessionID", "FIX::TriggerTradingSessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerTradingSessionSubID = {"_p_FIX__TriggerTradingSessionSubID", "FIX::TriggerTradingSessionSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__TriggerType = {"_p_FIX__TriggerType", "FIX::TriggerType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__URLLink = {"_p_FIX__URLLink", "FIX::URLLink *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UTCDATE = {"_p_FIX__UTCDATE", "FIX::UTCDATE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UTCDATEONLY = {"_p_FIX__UTCDATEONLY", "FIX::UTCDATEONLY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UTCTIMEONLY = {"_p_FIX__UTCTIMEONLY", "FIX::UTCTIMEONLY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UTCTIMESTAMP = {"_p_FIX__UTCTIMESTAMP", "FIX::UTCTIMESTAMP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingAdjustedQuantity = {"_p_FIX__UnderlyingAdjustedQuantity", "FIX::UnderlyingAdjustedQuantity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingAllocationPercent = {"_p_FIX__UnderlyingAllocationPercent", "FIX::UnderlyingAllocationPercent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingAttachmentPoint = {"_p_FIX__UnderlyingAttachmentPoint", "FIX::UnderlyingAttachmentPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCFICode = {"_p_FIX__UnderlyingCFICode", "FIX::UnderlyingCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCPProgram = {"_p_FIX__UnderlyingCPProgram", "FIX::UnderlyingCPProgram *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCPRegType = {"_p_FIX__UnderlyingCPRegType", "FIX::UnderlyingCPRegType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCapValue = {"_p_FIX__UnderlyingCapValue", "FIX::UnderlyingCapValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCashAmount = {"_p_FIX__UnderlyingCashAmount", "FIX::UnderlyingCashAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCashType = {"_p_FIX__UnderlyingCashType", "FIX::UnderlyingCashType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCollectAmount = {"_p_FIX__UnderlyingCollectAmount", "FIX::UnderlyingCollectAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingContractMultiplier = {"_p_FIX__UnderlyingContractMultiplier", "FIX::UnderlyingContractMultiplier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingContractMultiplierUnit = {"_p_FIX__UnderlyingContractMultiplierUnit", "FIX::UnderlyingContractMultiplierUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCountryOfIssue = {"_p_FIX__UnderlyingCountryOfIssue", "FIX::UnderlyingCountryOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCouponPaymentDate = {"_p_FIX__UnderlyingCouponPaymentDate", "FIX::UnderlyingCouponPaymentDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCouponRate = {"_p_FIX__UnderlyingCouponRate", "FIX::UnderlyingCouponRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCreditRating = {"_p_FIX__UnderlyingCreditRating", "FIX::UnderlyingCreditRating *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCurrency = {"_p_FIX__UnderlyingCurrency", "FIX::UnderlyingCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingCurrentValue = {"_p_FIX__UnderlyingCurrentValue", "FIX::UnderlyingCurrentValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingDeliveryAmount = {"_p_FIX__UnderlyingDeliveryAmount", "FIX::UnderlyingDeliveryAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingDetachmentPoint = {"_p_FIX__UnderlyingDetachmentPoint", "FIX::UnderlyingDetachmentPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingDirtyPrice = {"_p_FIX__UnderlyingDirtyPrice", "FIX::UnderlyingDirtyPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingEndPrice = {"_p_FIX__UnderlyingEndPrice", "FIX::UnderlyingEndPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingEndValue = {"_p_FIX__UnderlyingEndValue", "FIX::UnderlyingEndValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingExerciseStyle = {"_p_FIX__UnderlyingExerciseStyle", "FIX::UnderlyingExerciseStyle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingFXRate = {"_p_FIX__UnderlyingFXRate", "FIX::UnderlyingFXRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingFXRateCalc = {"_p_FIX__UnderlyingFXRateCalc", "FIX::UnderlyingFXRateCalc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingFactor = {"_p_FIX__UnderlyingFactor", "FIX::UnderlyingFactor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingFlowScheduleType = {"_p_FIX__UnderlyingFlowScheduleType", "FIX::UnderlyingFlowScheduleType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingIDSource = {"_p_FIX__UnderlyingIDSource", "FIX::UnderlyingIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrRegistry = {"_p_FIX__UnderlyingInstrRegistry", "FIX::UnderlyingInstrRegistry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartyID = {"_p_FIX__UnderlyingInstrumentPartyID", "FIX::UnderlyingInstrumentPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartyIDSource = {"_p_FIX__UnderlyingInstrumentPartyIDSource", "FIX::UnderlyingInstrumentPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartyRole = {"_p_FIX__UnderlyingInstrumentPartyRole", "FIX::UnderlyingInstrumentPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartySubID = {"_p_FIX__UnderlyingInstrumentPartySubID", "FIX::UnderlyingInstrumentPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingInstrumentPartySubIDType = {"_p_FIX__UnderlyingInstrumentPartySubIDType", "FIX::UnderlyingInstrumentPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingIssueDate = {"_p_FIX__UnderlyingIssueDate", "FIX::UnderlyingIssueDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingIssuer = {"_p_FIX__UnderlyingIssuer", "FIX::UnderlyingIssuer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLastPx = {"_p_FIX__UnderlyingLastPx", "FIX::UnderlyingLastPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLastQty = {"_p_FIX__UnderlyingLastQty", "FIX::UnderlyingLastQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegCFICode = {"_p_FIX__UnderlyingLegCFICode", "FIX::UnderlyingLegCFICode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegMaturityDate = {"_p_FIX__UnderlyingLegMaturityDate", "FIX::UnderlyingLegMaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegMaturityMonthYear = {"_p_FIX__UnderlyingLegMaturityMonthYear", "FIX::UnderlyingLegMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegMaturityTime = {"_p_FIX__UnderlyingLegMaturityTime", "FIX::UnderlyingLegMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegOptAttribute = {"_p_FIX__UnderlyingLegOptAttribute", "FIX::UnderlyingLegOptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegPutOrCall = {"_p_FIX__UnderlyingLegPutOrCall", "FIX::UnderlyingLegPutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityAltID = {"_p_FIX__UnderlyingLegSecurityAltID", "FIX::UnderlyingLegSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityAltIDSource = {"_p_FIX__UnderlyingLegSecurityAltIDSource", "FIX::UnderlyingLegSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityDesc = {"_p_FIX__UnderlyingLegSecurityDesc", "FIX::UnderlyingLegSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityExchange = {"_p_FIX__UnderlyingLegSecurityExchange", "FIX::UnderlyingLegSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityID = {"_p_FIX__UnderlyingLegSecurityID", "FIX::UnderlyingLegSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityIDSource = {"_p_FIX__UnderlyingLegSecurityIDSource", "FIX::UnderlyingLegSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecuritySubType = {"_p_FIX__UnderlyingLegSecuritySubType", "FIX::UnderlyingLegSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSecurityType = {"_p_FIX__UnderlyingLegSecurityType", "FIX::UnderlyingLegSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegStrikePrice = {"_p_FIX__UnderlyingLegStrikePrice", "FIX::UnderlyingLegStrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSymbol = {"_p_FIX__UnderlyingLegSymbol", "FIX::UnderlyingLegSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLegSymbolSfx = {"_p_FIX__UnderlyingLegSymbolSfx", "FIX::UnderlyingLegSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingLocaleOfIssue = {"_p_FIX__UnderlyingLocaleOfIssue", "FIX::UnderlyingLocaleOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingMaturityDate = {"_p_FIX__UnderlyingMaturityDate", "FIX::UnderlyingMaturityDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingMaturityDay = {"_p_FIX__UnderlyingMaturityDay", "FIX::UnderlyingMaturityDay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingMaturityMonthYear = {"_p_FIX__UnderlyingMaturityMonthYear", "FIX::UnderlyingMaturityMonthYear *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingMaturityTime = {"_p_FIX__UnderlyingMaturityTime", "FIX::UnderlyingMaturityTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingNotionalPercentageOutstanding = {"_p_FIX__UnderlyingNotionalPercentageOutstanding", "FIX::UnderlyingNotionalPercentageOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingOptAttribute = {"_p_FIX__UnderlyingOptAttribute", "FIX::UnderlyingOptAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding = {"_p_FIX__UnderlyingOriginalNotionalPercentageOutstanding", "FIX::UnderlyingOriginalNotionalPercentageOutstanding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPayAmount = {"_p_FIX__UnderlyingPayAmount", "FIX::UnderlyingPayAmount *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPriceDeterminationMethod = {"_p_FIX__UnderlyingPriceDeterminationMethod", "FIX::UnderlyingPriceDeterminationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPriceUnitOfMeasure = {"_p_FIX__UnderlyingPriceUnitOfMeasure", "FIX::UnderlyingPriceUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty = {"_p_FIX__UnderlyingPriceUnitOfMeasureQty", "FIX::UnderlyingPriceUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingProduct = {"_p_FIX__UnderlyingProduct", "FIX::UnderlyingProduct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPutOrCall = {"_p_FIX__UnderlyingPutOrCall", "FIX::UnderlyingPutOrCall *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingPx = {"_p_FIX__UnderlyingPx", "FIX::UnderlyingPx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingQty = {"_p_FIX__UnderlyingQty", "FIX::UnderlyingQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRedemptionDate = {"_p_FIX__UnderlyingRedemptionDate", "FIX::UnderlyingRedemptionDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRepoCollateralSecurityType = {"_p_FIX__UnderlyingRepoCollateralSecurityType", "FIX::UnderlyingRepoCollateralSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRepurchaseRate = {"_p_FIX__UnderlyingRepurchaseRate", "FIX::UnderlyingRepurchaseRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRepurchaseTerm = {"_p_FIX__UnderlyingRepurchaseTerm", "FIX::UnderlyingRepurchaseTerm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingRestructuringType = {"_p_FIX__UnderlyingRestructuringType", "FIX::UnderlyingRestructuringType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityAltID = {"_p_FIX__UnderlyingSecurityAltID", "FIX::UnderlyingSecurityAltID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityAltIDSource = {"_p_FIX__UnderlyingSecurityAltIDSource", "FIX::UnderlyingSecurityAltIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityDesc = {"_p_FIX__UnderlyingSecurityDesc", "FIX::UnderlyingSecurityDesc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityExchange = {"_p_FIX__UnderlyingSecurityExchange", "FIX::UnderlyingSecurityExchange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityID = {"_p_FIX__UnderlyingSecurityID", "FIX::UnderlyingSecurityID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityIDSource = {"_p_FIX__UnderlyingSecurityIDSource", "FIX::UnderlyingSecurityIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecuritySubType = {"_p_FIX__UnderlyingSecuritySubType", "FIX::UnderlyingSecuritySubType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSecurityType = {"_p_FIX__UnderlyingSecurityType", "FIX::UnderlyingSecurityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSeniority = {"_p_FIX__UnderlyingSeniority", "FIX::UnderlyingSeniority *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlMethod = {"_p_FIX__UnderlyingSettlMethod", "FIX::UnderlyingSettlMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlPrice = {"_p_FIX__UnderlyingSettlPrice", "FIX::UnderlyingSettlPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlPriceType = {"_p_FIX__UnderlyingSettlPriceType", "FIX::UnderlyingSettlPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlementDate = {"_p_FIX__UnderlyingSettlementDate", "FIX::UnderlyingSettlementDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlementStatus = {"_p_FIX__UnderlyingSettlementStatus", "FIX::UnderlyingSettlementStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSettlementType = {"_p_FIX__UnderlyingSettlementType", "FIX::UnderlyingSettlementType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStartValue = {"_p_FIX__UnderlyingStartValue", "FIX::UnderlyingStartValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStateOrProvinceOfIssue = {"_p_FIX__UnderlyingStateOrProvinceOfIssue", "FIX::UnderlyingStateOrProvinceOfIssue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStipType = {"_p_FIX__UnderlyingStipType", "FIX::UnderlyingStipType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStipValue = {"_p_FIX__UnderlyingStipValue", "FIX::UnderlyingStipValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStrikeCurrency = {"_p_FIX__UnderlyingStrikeCurrency", "FIX::UnderlyingStrikeCurrency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingStrikePrice = {"_p_FIX__UnderlyingStrikePrice", "FIX::UnderlyingStrikePrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSymbol = {"_p_FIX__UnderlyingSymbol", "FIX::UnderlyingSymbol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingSymbolSfx = {"_p_FIX__UnderlyingSymbolSfx", "FIX::UnderlyingSymbolSfx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingTimeUnit = {"_p_FIX__UnderlyingTimeUnit", "FIX::UnderlyingTimeUnit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingTradingSessionID = {"_p_FIX__UnderlyingTradingSessionID", "FIX::UnderlyingTradingSessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingTradingSessionSubID = {"_p_FIX__UnderlyingTradingSessionSubID", "FIX::UnderlyingTradingSessionSubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingUnitOfMeasure = {"_p_FIX__UnderlyingUnitOfMeasure", "FIX::UnderlyingUnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnderlyingUnitOfMeasureQty = {"_p_FIX__UnderlyingUnitOfMeasureQty", "FIX::UnderlyingUnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartyID = {"_p_FIX__UndlyInstrumentPartyID", "FIX::UndlyInstrumentPartyID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartyIDSource = {"_p_FIX__UndlyInstrumentPartyIDSource", "FIX::UndlyInstrumentPartyIDSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartyRole = {"_p_FIX__UndlyInstrumentPartyRole", "FIX::UndlyInstrumentPartyRole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartySubID = {"_p_FIX__UndlyInstrumentPartySubID", "FIX::UndlyInstrumentPartySubID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UndlyInstrumentPartySubIDType = {"_p_FIX__UndlyInstrumentPartySubIDType", "FIX::UndlyInstrumentPartySubIDType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnitOfMeasure = {"_p_FIX__UnitOfMeasure", "FIX::UnitOfMeasure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnitOfMeasureQty = {"_p_FIX__UnitOfMeasureQty", "FIX::UnitOfMeasureQty *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnsolicitedIndicator = {"_p_FIX__UnsolicitedIndicator", "FIX::UnsolicitedIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnsupportedMessageType = {"_p_FIX__UnsupportedMessageType", "FIX::UnsupportedMessageType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UnsupportedVersion = {"_p_FIX__UnsupportedVersion", "FIX::UnsupportedVersion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Urgency = {"_p_FIX__Urgency", "FIX::Urgency *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UserRequestID = {"_p_FIX__UserRequestID", "FIX::UserRequestID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UserRequestType = {"_p_FIX__UserRequestType", "FIX::UserRequestType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UserStatus = {"_p_FIX__UserStatus", "FIX::UserStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UserStatusText = {"_p_FIX__UserStatusText", "FIX::UserStatusText *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Username = {"_p_FIX__Username", "FIX::Username *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UtcDateField = {"_p_FIX__UtcDateField", "FIX::UtcDateField *|FIX::UtcDateOnlyField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UtcTimeOnlyField = {"_p_FIX__UtcTimeOnlyField", "FIX::UtcTimeOnlyField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__UtcTimeStampField = {"_p_FIX__UtcTimeStampField", "FIX::UtcTimeStampField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ValidUntilTime = {"_p_FIX__ValidUntilTime", "FIX::ValidUntilTime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ValuationMethod = {"_p_FIX__ValuationMethod", "FIX::ValuationMethod *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__ValueOfFutures = {"_p_FIX__ValueOfFutures", "FIX::ValueOfFutures *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__VenueType = {"_p_FIX__VenueType", "FIX::VenueType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Volatility = {"_p_FIX__Volatility", "FIX::Volatility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__WaveNo = {"_p_FIX__WaveNo", "FIX::WaveNo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__WorkingIndicator = {"_p_FIX__WorkingIndicator", "FIX::WorkingIndicator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__WtAverageLiquidity = {"_p_FIX__WtAverageLiquidity", "FIX::WtAverageLiquidity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__XMLDATA = {"_p_FIX__XMLDATA", "FIX::XMLDATA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__XmlData = {"_p_FIX__XmlData", "FIX::XmlData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__XmlDataLen = {"_p_FIX__XmlDataLen", "FIX::XmlDataLen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__Yield = {"_p_FIX__Yield", "FIX::Yield *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldCalcDate = {"_p_FIX__YieldCalcDate", "FIX::YieldCalcDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldRedemptionDate = {"_p_FIX__YieldRedemptionDate", "FIX::YieldRedemptionDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldRedemptionPrice = {"_p_FIX__YieldRedemptionPrice", "FIX::YieldRedemptionPrice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldRedemptionPriceType = {"_p_FIX__YieldRedemptionPriceType", "FIX::YieldRedemptionPriceType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FIX__YieldType = {"_p_FIX__YieldType", "FIX::YieldType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Fields = {"_p_Fields", "Fields *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Group = {"_p_Group", "Group *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Groups = {"_p_Groups", "Groups *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IntArray = {"_p_IntArray", "IntArray *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IntField = {"_p_IntField", "IntField *|LengthField *|NumInGroupField *|SeqNumField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Log = {"_p_Log", "Log *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LogFactory = {"_p_LogFactory", "LogFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MessageStore = {"_p_MessageStore", "MessageStore *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MessageStoreFactory = {"_p_MessageStoreFactory", "MessageStoreFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MsgType = {"_p_MsgType", "MsgType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Mutex = {"_p_Mutex", "Mutex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Responder = {"_p_Responder", "Responder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SessionID = {"_p_SessionID", "SessionID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StringField = {"_p_StringField", "TzTimeStampField *|LocalMktDateField *|DayOfMonthField *|MonthField *|DataField *|ExchangeField *|MultipleCharValueField *|MultipleStringValueField *|TzTimeOnlyField *|CountryField *|MonthYearField *|MultipleValueStringField *|CurrencyField *|StringField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TimeRange = {"_p_TimeRange", "TimeRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UtcDate = {"_p_UtcDate", "UtcDate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UtcDateField = {"_p_UtcDateField", "UtcDateField *|UtcDateOnlyField *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UtcTimeOnly = {"_p_UtcTimeOnly", "UtcTimeOnly *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UtcTimeStamp = {"_p_UtcTimeStamp", "UtcTimeStamp *", 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", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_iterator = {"_p_const_iterator", "const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_g_const_iterator = {"_p_g_const_iterator", "g_const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_g_iterator = {"_p_g_iterator", "g_iterator *", 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_iterator = {"_p_iterator", "iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_message_order = {"_p_message_order", "message_order *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_FIX__DataDictionary = {"_p_p_FIX__DataDictionary", "FIX::DataDictionary **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__setT_FIX__SessionID_t = {"_p_std__setT_FIX__SessionID_t", "std::set< FIX::SessionID > *", 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 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__string_t = {"_p_std__vectorT_std__string_t", "std::vector< std::string > *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_ApplVerID,
  &_swigt__p_Application,
  &_swigt__p_BeginString,
  &_swigt__p_DOMDocumentPtr,
  &_swigt__p_Data,
  &_swigt__p_DataDictionary,
  &_swigt__p_DataDictionaryProvider,
  &_swigt__p_Dictionaries,
  &_swigt__p_DoubleField,
  &_swigt__p_FIX__AMT,
  &_swigt__p_FIX__Acceptor,
  &_swigt__p_FIX__Account,
  &_swigt__p_FIX__AccountType,
  &_swigt__p_FIX__AccruedInterestAmt,
  &_swigt__p_FIX__AccruedInterestRate,
  &_swigt__p_FIX__AcctIDSource,
  &_swigt__p_FIX__Adjustment,
  &_swigt__p_FIX__AdjustmentType,
  &_swigt__p_FIX__AdvId,
  &_swigt__p_FIX__AdvRefID,
  &_swigt__p_FIX__AdvSide,
  &_swigt__p_FIX__AdvTransType,
  &_swigt__p_FIX__AffectedOrderID,
  &_swigt__p_FIX__AffectedSecondaryOrderID,
  &_swigt__p_FIX__AffirmStatus,
  &_swigt__p_FIX__AggregatedBook,
  &_swigt__p_FIX__AggressorIndicator,
  &_swigt__p_FIX__AgreementCurrency,
  &_swigt__p_FIX__AgreementDate,
  &_swigt__p_FIX__AgreementDesc,
  &_swigt__p_FIX__AgreementID,
  &_swigt__p_FIX__AllocAccount,
  &_swigt__p_FIX__AllocAccountType,
  &_swigt__p_FIX__AllocAccruedInterestAmt,
  &_swigt__p_FIX__AllocAcctIDSource,
  &_swigt__p_FIX__AllocAvgPx,
  &_swigt__p_FIX__AllocCancReplaceReason,
  &_swigt__p_FIX__AllocClearingFeeIndicator,
  &_swigt__p_FIX__AllocCustomerCapacity,
  &_swigt__p_FIX__AllocHandlInst,
  &_swigt__p_FIX__AllocID,
  &_swigt__p_FIX__AllocInterestAtMaturity,
  &_swigt__p_FIX__AllocIntermedReqType,
  &_swigt__p_FIX__AllocLinkID,
  &_swigt__p_FIX__AllocLinkType,
  &_swigt__p_FIX__AllocMethod,
  &_swigt__p_FIX__AllocNetMoney,
  &_swigt__p_FIX__AllocNoOrdersType,
  &_swigt__p_FIX__AllocPositionEffect,
  &_swigt__p_FIX__AllocPrice,
  &_swigt__p_FIX__AllocQty,
  &_swigt__p_FIX__AllocRejCode,
  &_swigt__p_FIX__AllocReportID,
  &_swigt__p_FIX__AllocReportRefID,
  &_swigt__p_FIX__AllocReportType,
  &_swigt__p_FIX__AllocSettlCurrAmt,
  &_swigt__p_FIX__AllocSettlCurrency,
  &_swigt__p_FIX__AllocSettlInstType,
  &_swigt__p_FIX__AllocShares,
  &_swigt__p_FIX__AllocStatus,
  &_swigt__p_FIX__AllocText,
  &_swigt__p_FIX__AllocTransType,
  &_swigt__p_FIX__AllocType,
  &_swigt__p_FIX__AllowableOneSidednessCurr,
  &_swigt__p_FIX__AllowableOneSidednessPct,
  &_swigt__p_FIX__AllowableOneSidednessValue,
  &_swigt__p_FIX__AltMDSourceID,
  &_swigt__p_FIX__ApplBegSeqNum,
  &_swigt__p_FIX__ApplEndSeqNum,
  &_swigt__p_FIX__ApplExtID,
  &_swigt__p_FIX__ApplID,
  &_swigt__p_FIX__ApplLastSeqNum,
  &_swigt__p_FIX__ApplNewSeqNum,
  &_swigt__p_FIX__ApplQueueAction,
  &_swigt__p_FIX__ApplQueueDepth,
  &_swigt__p_FIX__ApplQueueMax,
  &_swigt__p_FIX__ApplQueueResolution,
  &_swigt__p_FIX__ApplReportID,
  &_swigt__p_FIX__ApplReportType,
  &_swigt__p_FIX__ApplReqID,
  &_swigt__p_FIX__ApplReqType,
  &_swigt__p_FIX__ApplResendFlag,
  &_swigt__p_FIX__ApplResponseError,
  &_swigt__p_FIX__ApplResponseID,
  &_swigt__p_FIX__ApplResponseType,
  &_swigt__p_FIX__ApplSeqNum,
  &_swigt__p_FIX__ApplTotalMessageCount,
  &_swigt__p_FIX__ApplVerID,
  &_swigt__p_FIX__Application,
  &_swigt__p_FIX__AsOfIndicator,
  &_swigt__p_FIX__AsgnRptID,
  &_swigt__p_FIX__AssignmentMethod,
  &_swigt__p_FIX__AssignmentUnit,
  &_swigt__p_FIX__AttachmentPoint,
  &_swigt__p_FIX__AutoAcceptIndicator,
  &_swigt__p_FIX__AvgParPx,
  &_swigt__p_FIX__AvgPrxPrecision,
  &_swigt__p_FIX__AvgPx,
  &_swigt__p_FIX__AvgPxIndicator,
  &_swigt__p_FIX__AvgPxPrecision,
  &_swigt__p_FIX__BOOLEAN,
  &_swigt__p_FIX__BasisFeatureDate,
  &_swigt__p_FIX__BasisFeaturePrice,
  &_swigt__p_FIX__BasisPxType,
  &_swigt__p_FIX__BeginSeqNo,
  &_swigt__p_FIX__BeginString,
  &_swigt__p_FIX__Benchmark,
  &_swigt__p_FIX__BenchmarkCurveCurrency,
  &_swigt__p_FIX__BenchmarkCurveName,
  &_swigt__p_FIX__BenchmarkCurvePoint,
  &_swigt__p_FIX__BenchmarkPrice,
  &_swigt__p_FIX__BenchmarkPriceType,
  &_swigt__p_FIX__BenchmarkSecurityID,
  &_swigt__p_FIX__BenchmarkSecurityIDSource,
  &_swigt__p_FIX__BidDescriptor,
  &_swigt__p_FIX__BidDescriptorType,
  &_swigt__p_FIX__BidForwardPoints,
  &_swigt__p_FIX__BidForwardPoints2,
  &_swigt__p_FIX__BidID,
  &_swigt__p_FIX__BidPx,
  &_swigt__p_FIX__BidRequestTransType,
  &_swigt__p_FIX__BidSize,
  &_swigt__p_FIX__BidSpotRate,
  &_swigt__p_FIX__BidSwapPoints,
  &_swigt__p_FIX__BidTradeType,
  &_swigt__p_FIX__BidType,
  &_swigt__p_FIX__BidYield,
  &_swigt__p_FIX__BodyLength,
  &_swigt__p_FIX__BookingRefID,
  &_swigt__p_FIX__BookingType,
  &_swigt__p_FIX__BookingUnit,
  &_swigt__p_FIX__BoolField,
  &_swigt__p_FIX__BrokerOfCredit,
  &_swigt__p_FIX__BusinessRejectReason,
  &_swigt__p_FIX__BusinessRejectRefID,
  &_swigt__p_FIX__BuyVolume,
  &_swigt__p_FIX__CFICode,
  &_swigt__p_FIX__CHAR,
  &_swigt__p_FIX__COUNTRY,
  &_swigt__p_FIX__CPProgram,
  &_swigt__p_FIX__CPRegType,
  &_swigt__p_FIX__CURRENCY,
  &_swigt__p_FIX__CalculatedCcyLastQty,
  &_swigt__p_FIX__CancellationRights,
  &_swigt__p_FIX__CapPrice,
  &_swigt__p_FIX__CardExpDate,
  &_swigt__p_FIX__CardHolderName,
  &_swigt__p_FIX__CardIssNo,
  &_swigt__p_FIX__CardIssNum,
  &_swigt__p_FIX__CardNumber,
  &_swigt__p_FIX__CardStartDate,
  &_swigt__p_FIX__CashDistribAgentAcctName,
  &_swigt__p_FIX__CashDistribAgentAcctNumber,
  &_swigt__p_FIX__CashDistribAgentCode,
  &_swigt__p_FIX__CashDistribAgentName,
  &_swigt__p_FIX__CashDistribCurr,
  &_swigt__p_FIX__CashDistribPayRef,
  &_swigt__p_FIX__CashMargin,
  &_swigt__p_FIX__CashOrderQty,
  &_swigt__p_FIX__CashOutstanding,
  &_swigt__p_FIX__CashSettlAgentAcctName,
  &_swigt__p_FIX__CashSettlAgentAcctNum,
  &_swigt__p_FIX__CashSettlAgentCode,
  &_swigt__p_FIX__CashSettlAgentContactName,
  &_swigt__p_FIX__CashSettlAgentContactPhone,
  &_swigt__p_FIX__CashSettlAgentName,
  &_swigt__p_FIX__CcyAmt,
  &_swigt__p_FIX__CharField,
  &_swigt__p_FIX__CheckSum,
  &_swigt__p_FIX__CheckSumField,
  &_swigt__p_FIX__ClOrdID,
  &_swigt__p_FIX__ClOrdLinkID,
  &_swigt__p_FIX__ClearingAccount,
  &_swigt__p_FIX__ClearingBusinessDate,
  &_swigt__p_FIX__ClearingFeeIndicator,
  &_swigt__p_FIX__ClearingFirm,
  &_swigt__p_FIX__ClearingInstruction,
  &_swigt__p_FIX__ClientBidID,
  &_swigt__p_FIX__ClientID,
  &_swigt__p_FIX__CollAction,
  &_swigt__p_FIX__CollApplType,
  &_swigt__p_FIX__CollAsgnID,
  &_swigt__p_FIX__CollAsgnReason,
  &_swigt__p_FIX__CollAsgnRefID,
  &_swigt__p_FIX__CollAsgnRejectReason,
  &_swigt__p_FIX__CollAsgnRespType,
  &_swigt__p_FIX__CollAsgnTransType,
  &_swigt__p_FIX__CollInquiryID,
  &_swigt__p_FIX__CollInquiryQualifier,
  &_swigt__p_FIX__CollInquiryResult,
  &_swigt__p_FIX__CollInquiryStatus,
  &_swigt__p_FIX__CollReqID,
  &_swigt__p_FIX__CollRespID,
  &_swigt__p_FIX__CollRptID,
  &_swigt__p_FIX__CollStatus,
  &_swigt__p_FIX__CommCurrency,
  &_swigt__p_FIX__CommType,
  &_swigt__p_FIX__Commission,
  &_swigt__p_FIX__ComplexEventCondition,
  &_swigt__p_FIX__ComplexEventEndDate,
  &_swigt__p_FIX__ComplexEventEndTime,
  &_swigt__p_FIX__ComplexEventPrice,
  &_swigt__p_FIX__ComplexEventPriceBoundaryMethod,
  &_swigt__p_FIX__ComplexEventPriceBoundaryPrecision,
  &_swigt__p_FIX__ComplexEventPriceTimeType,
  &_swigt__p_FIX__ComplexEventStartDate,
  &_swigt__p_FIX__ComplexEventStartTime,
  &_swigt__p_FIX__ComplexEventType,
  &_swigt__p_FIX__ComplexOptPayoutAmount,
  &_swigt__p_FIX__ComplianceID,
  &_swigt__p_FIX__Concession,
  &_swigt__p_FIX__ConfigError,
  &_swigt__p_FIX__ConfirmID,
  &_swigt__p_FIX__ConfirmRefID,
  &_swigt__p_FIX__ConfirmRejReason,
  &_swigt__p_FIX__ConfirmReqID,
  &_swigt__p_FIX__ConfirmStatus,
  &_swigt__p_FIX__ConfirmTransType,
  &_swigt__p_FIX__ConfirmType,
  &_swigt__p_FIX__ContAmtCurr,
  &_swigt__p_FIX__ContAmtType,
  &_swigt__p_FIX__ContAmtValue,
  &_swigt__p_FIX__ContIntRptID,
  &_swigt__p_FIX__ContingencyType,
  &_swigt__p_FIX__ContraBroker,
  &_swigt__p_FIX__ContraLegRefID,
  &_swigt__p_FIX__ContraTradeQty,
  &_swigt__p_FIX__ContraTradeTime,
  &_swigt__p_FIX__ContraTrader,
  &_swigt__p_FIX__ContractMultiplier,
  &_swigt__p_FIX__ContractMultiplierUnit,
  &_swigt__p_FIX__ContractSettlMonth,
  &_swigt__p_FIX__ContraryInstructionIndicator,
  &_swigt__p_FIX__CopyMsgIndicator,
  &_swigt__p_FIX__CorporateAction,
  &_swigt__p_FIX__Country,
  &_swigt__p_FIX__CountryOfIssue,
  &_swigt__p_FIX__CouponPaymentDate,
  &_swigt__p_FIX__CouponRate,
  &_swigt__p_FIX__CoveredOrUncovered,
  &_swigt__p_FIX__CreditRating,
  &_swigt__p_FIX__CrossID,
  &_swigt__p_FIX__CrossPercent,
  &_swigt__p_FIX__CrossPrioritization,
  &_swigt__p_FIX__CrossType,
  &_swigt__p_FIX__CstmApplVerID,
  &_swigt__p_FIX__CumQty,
  &_swigt__p_FIX__Currency,
  &_swigt__p_FIX__CurrencyRatio,
  &_swigt__p_FIX__CustDirectedOrder,
  &_swigt__p_FIX__CustOrderCapacity,
  &_swigt__p_FIX__CustOrderHandlingInst,
  &_swigt__p_FIX__CustomerOrFirm,
  &_swigt__p_FIX__CxlQty,
  &_swigt__p_FIX__CxlRejReason,
  &_swigt__p_FIX__CxlRejResponseTo,
  &_swigt__p_FIX__CxlType,
  &_swigt__p_FIX__DATA,
  &_swigt__p_FIX__DAYOFMONTH,
  &_swigt__p_FIX__DKReason,
  &_swigt__p_FIX__DataDictionary,
  &_swigt__p_FIX__DataDictionaryNotFound,
  &_swigt__p_FIX__DateOfBirth,
  &_swigt__p_FIX__DatedDate,
  &_swigt__p_FIX__DayAvgPx,
  &_swigt__p_FIX__DayBookingInst,
  &_swigt__p_FIX__DayCumQty,
  &_swigt__p_FIX__DayOrderQty,
  &_swigt__p_FIX__DealingCapacity,
  &_swigt__p_FIX__DefBidSize,
  &_swigt__p_FIX__DefOfferSize,
  &_swigt__p_FIX__DefaultApplExtID,
  &_swigt__p_FIX__DefaultApplVerID,
  &_swigt__p_FIX__DefaultCstmApplVerID,
  &_swigt__p_FIX__DefaultVerIndicator,
  &_swigt__p_FIX__DeleteReason,
  &_swigt__p_FIX__DeliverToCompID,
  &_swigt__p_FIX__DeliverToLocationID,
  &_swigt__p_FIX__DeliverToSubID,
  &_swigt__p_FIX__DeliveryDate,
  &_swigt__p_FIX__DeliveryForm,
  &_swigt__p_FIX__DeliveryType,
  &_swigt__p_FIX__DerivFlexProductEligibilityIndicator,
  &_swigt__p_FIX__DerivativeCFICode,
  &_swigt__p_FIX__DerivativeCapPrice,
  &_swigt__p_FIX__DerivativeContractMultiplier,
  &_swigt__p_FIX__DerivativeContractMultiplierUnit,
  &_swigt__p_FIX__DerivativeContractSettlMonth,
  &_swigt__p_FIX__DerivativeCountryOfIssue,
  &_swigt__p_FIX__DerivativeEncodedIssuer,
  &_swigt__p_FIX__DerivativeEncodedIssuerLen,
  &_swigt__p_FIX__DerivativeEncodedSecurityDesc,
  &_swigt__p_FIX__DerivativeEncodedSecurityDescLen,
  &_swigt__p_FIX__DerivativeEventDate,
  &_swigt__p_FIX__DerivativeEventPx,
  &_swigt__p_FIX__DerivativeEventText,
  &_swigt__p_FIX__DerivativeEventTime,
  &_swigt__p_FIX__DerivativeEventType,
  &_swigt__p_FIX__DerivativeExerciseStyle,
  &_swigt__p_FIX__DerivativeFloorPrice,
  &_swigt__p_FIX__DerivativeFlowScheduleType,
  &_swigt__p_FIX__DerivativeFuturesValuationMethod,
  &_swigt__p_FIX__DerivativeInstrAttribType,
  &_swigt__p_FIX__DerivativeInstrAttribValue,
  &_swigt__p_FIX__DerivativeInstrRegistry,
  &_swigt__p_FIX__DerivativeInstrmtAssignmentMethod,
  &_swigt__p_FIX__DerivativeInstrumentPartyID,
  &_swigt__p_FIX__DerivativeInstrumentPartyIDSource,
  &_swigt__p_FIX__DerivativeInstrumentPartyRole,
  &_swigt__p_FIX__DerivativeInstrumentPartySubID,
  &_swigt__p_FIX__DerivativeInstrumentPartySubIDType,
  &_swigt__p_FIX__DerivativeIssueDate,
  &_swigt__p_FIX__DerivativeIssuer,
  &_swigt__p_FIX__DerivativeListMethod,
  &_swigt__p_FIX__DerivativeLocaleOfIssue,
  &_swigt__p_FIX__DerivativeMaturityDate,
  &_swigt__p_FIX__DerivativeMaturityMonthYear,
  &_swigt__p_FIX__DerivativeMaturityTime,
  &_swigt__p_FIX__DerivativeMinPriceIncrement,
  &_swigt__p_FIX__DerivativeMinPriceIncrementAmount,
  &_swigt__p_FIX__DerivativeNTPositionLimit,
  &_swigt__p_FIX__DerivativeOptAttribute,
  &_swigt__p_FIX__DerivativeOptPayAmount,
  &_swigt__p_FIX__DerivativePositionLimit,
  &_swigt__p_FIX__DerivativePriceQuoteMethod,
  &_swigt__p_FIX__DerivativePriceUnitOfMeasure,
  &_swigt__p_FIX__DerivativePriceUnitOfMeasureQty,
  &_swigt__p_FIX__DerivativeProduct,
  &_swigt__p_FIX__DerivativeProductComplex,
  &_swigt__p_FIX__DerivativePutOrCall,
  &_swigt__p_FIX__DerivativeSecurityAltID,
  &_swigt__p_FIX__DerivativeSecurityAltIDSource,
  &_swigt__p_FIX__DerivativeSecurityDesc,
  &_swigt__p_FIX__DerivativeSecurityExchange,
  &_swigt__p_FIX__DerivativeSecurityGroup,
  &_swigt__p_FIX__DerivativeSecurityID,
  &_swigt__p_FIX__DerivativeSecurityIDSource,
  &_swigt__p_FIX__DerivativeSecurityStatus,
  &_swigt__p_FIX__DerivativeSecuritySubType,
  &_swigt__p_FIX__DerivativeSecurityType,
  &_swigt__p_FIX__DerivativeSecurityXML,
  &_swigt__p_FIX__DerivativeSecurityXMLLen,
  &_swigt__p_FIX__DerivativeSecurityXMLSchema,
  &_swigt__p_FIX__DerivativeSettlMethod,
  &_swigt__p_FIX__DerivativeSettleOnOpenFlag,
  &_swigt__p_FIX__DerivativeStateOrProvinceOfIssue,
  &_swigt__p_FIX__DerivativeStrikeCurrency,
  &_swigt__p_FIX__DerivativeStrikeMultiplier,
  &_swigt__p_FIX__DerivativeStrikePrice,
  &_swigt__p_FIX__DerivativeStrikeValue,
  &_swigt__p_FIX__DerivativeSymbol,
  &_swigt__p_FIX__DerivativeSymbolSfx,
  &_swigt__p_FIX__DerivativeTimeUnit,
  &_swigt__p_FIX__DerivativeUnitOfMeasure,
  &_swigt__p_FIX__DerivativeUnitOfMeasureQty,
  &_swigt__p_FIX__DerivativeValuationMethod,
  &_swigt__p_FIX__Designation,
  &_swigt__p_FIX__DeskID,
  &_swigt__p_FIX__DeskOrderHandlingInst,
  &_swigt__p_FIX__DeskType,
  &_swigt__p_FIX__DeskTypeSource,
  &_swigt__p_FIX__DetachmentPoint,
  &_swigt__p_FIX__Dictionary,
  &_swigt__p_FIX__Dictionary__Data__const_iterator,
  &_swigt__p_FIX__DiscretionInst,
  &_swigt__p_FIX__DiscretionLimitType,
  &_swigt__p_FIX__DiscretionMoveType,
  &_swigt__p_FIX__DiscretionOffset,
  &_swigt__p_FIX__DiscretionOffsetType,
  &_swigt__p_FIX__DiscretionOffsetValue,
  &_swigt__p_FIX__DiscretionPrice,
  &_swigt__p_FIX__DiscretionRoundDirection,
  &_swigt__p_FIX__DiscretionScope,
  &_swigt__p_FIX__DisplayHighQty,
  &_swigt__p_FIX__DisplayLowQty,
  &_swigt__p_FIX__DisplayMethod,
  &_swigt__p_FIX__DisplayMinIncr,
  &_swigt__p_FIX__DisplayQty,
  &_swigt__p_FIX__DisplayWhen,
  &_swigt__p_FIX__DistribPaymentMethod,
  &_swigt__p_FIX__DistribPercentage,
  &_swigt__p_FIX__DividendYield,
  &_swigt__p_FIX__DlvyInst,
  &_swigt__p_FIX__DlvyInstType,
  &_swigt__p_FIX__DoNotSend,
  &_swigt__p_FIX__DoubleField,
  &_swigt__p_FIX__DueToRelated,
  &_swigt__p_FIX__DuplicateFieldNumber,
  &_swigt__p_FIX__EFPTrackingError,
  &_swigt__p_FIX__EXCHANGE,
  &_swigt__p_FIX__EffectiveTime,
  &_swigt__p_FIX__EmailThreadID,
  &_swigt__p_FIX__EmailType,
  &_swigt__p_FIX__EncodedAllocText,
  &_swigt__p_FIX__EncodedAllocTextLen,
  &_swigt__p_FIX__EncodedHeadline,
  &_swigt__p_FIX__EncodedHeadlineLen,
  &_swigt__p_FIX__EncodedIssuer,
  &_swigt__p_FIX__EncodedIssuerLen,
  &_swigt__p_FIX__EncodedLegIssuer,
  &_swigt__p_FIX__EncodedLegIssuerLen,
  &_swigt__p_FIX__EncodedLegSecurityDesc,
  &_swigt__p_FIX__EncodedLegSecurityDescLen,
  &_swigt__p_FIX__EncodedListExecInst,
  &_swigt__p_FIX__EncodedListExecInstLen,
  &_swigt__p_FIX__EncodedListStatusText,
  &_swigt__p_FIX__EncodedListStatusTextLen,
  &_swigt__p_FIX__EncodedMktSegmDesc,
  &_swigt__p_FIX__EncodedMktSegmDescLen,
  &_swigt__p_FIX__EncodedSecurityDesc,
  &_swigt__p_FIX__EncodedSecurityDescLen,
  &_swigt__p_FIX__EncodedSecurityListDesc,
  &_swigt__p_FIX__EncodedSecurityListDescLen,
  &_swigt__p_FIX__EncodedSubject,
  &_swigt__p_FIX__EncodedSubjectLen,
  &_swigt__p_FIX__EncodedText,
  &_swigt__p_FIX__EncodedTextLen,
  &_swigt__p_FIX__EncodedUnderlyingIssuer,
  &_swigt__p_FIX__EncodedUnderlyingIssuerLen,
  &_swigt__p_FIX__EncodedUnderlyingSecurityDesc,
  &_swigt__p_FIX__EncodedUnderlyingSecurityDescLen,
  &_swigt__p_FIX__EncryptMethod,
  &_swigt__p_FIX__EncryptedNewPassword,
  &_swigt__p_FIX__EncryptedNewPasswordLen,
  &_swigt__p_FIX__EncryptedPassword,
  &_swigt__p_FIX__EncryptedPasswordLen,
  &_swigt__p_FIX__EncryptedPasswordMethod,
  &_swigt__p_FIX__EndAccruedInterestAmt,
  &_swigt__p_FIX__EndCash,
  &_swigt__p_FIX__EndDate,
  &_swigt__p_FIX__EndMaturityMonthYear,
  &_swigt__p_FIX__EndSeqNo,
  &_swigt__p_FIX__EndStrikePxRange,
  &_swigt__p_FIX__EndTickPriceRange,
  &_swigt__p_FIX__EventDate,
  &_swigt__p_FIX__EventPx,
  &_swigt__p_FIX__EventText,
  &_swigt__p_FIX__EventTime,
  &_swigt__p_FIX__EventType,
  &_swigt__p_FIX__ExDate,
  &_swigt__p_FIX__ExDestination,
  &_swigt__p_FIX__ExDestinationIDSource,
  &_swigt__p_FIX__Exception,
  &_swigt__p_FIX__ExchangeForPhysical,
  &_swigt__p_FIX__ExchangeRule,
  &_swigt__p_FIX__ExchangeSpecialInstructions,
  &_swigt__p_FIX__ExecAckStatus,
  &_swigt__p_FIX__ExecBroker,
  &_swigt__p_FIX__ExecID,
  &_swigt__p_FIX__ExecInst,
  &_swigt__p_FIX__ExecInstValue,
  &_swigt__p_FIX__ExecPriceAdjustment,
  &_swigt__p_FIX__ExecPriceType,
  &_swigt__p_FIX__ExecRefID,
  &_swigt__p_FIX__ExecRestatementReason,
  &_swigt__p_FIX__ExecTransType,
  &_swigt__p_FIX__ExecType,
  &_swigt__p_FIX__ExecValuationPoint,
  &_swigt__p_FIX__ExerciseMethod,
  &_swigt__p_FIX__ExerciseStyle,
  &_swigt__p_FIX__ExpQty,
  &_swigt__p_FIX__ExpType,
  &_swigt__p_FIX__ExpirationCycle,
  &_swigt__p_FIX__ExpirationQtyType,
  &_swigt__p_FIX__ExpireDate,
  &_swigt__p_FIX__ExpireTime,
  &_swigt__p_FIX__FLOAT,
  &_swigt__p_FIX__Factor,
  &_swigt__p_FIX__FairValue,
  &_swigt__p_FIX__FeeMultiplier,
  &_swigt__p_FIX__FieldBase,
  &_swigt__p_FIX__FieldConvertError,
  &_swigt__p_FIX__FieldMap,
  &_swigt__p_FIX__FieldMap__Fields__const_iterator,
  &_swigt__p_FIX__FieldMap__Groups__const_iterator,
  &_swigt__p_FIX__FieldNotFound,
  &_swigt__p_FIX__FileLog,
  &_swigt__p_FIX__FileLogFactory,
  &_swigt__p_FIX__FileStore,
  &_swigt__p_FIX__FileStoreFactory,
  &_swigt__p_FIX__FillExecID,
  &_swigt__p_FIX__FillLiquidityInd,
  &_swigt__p_FIX__FillPx,
  &_swigt__p_FIX__FillQty,
  &_swigt__p_FIX__FinancialStatus,
  &_swigt__p_FIX__FirmTradeID,
  &_swigt__p_FIX__FirstPx,
  &_swigt__p_FIX__FlexProductEligibilityIndicator,
  &_swigt__p_FIX__FlexibleIndicator,
  &_swigt__p_FIX__FloorPrice,
  &_swigt__p_FIX__FlowScheduleType,
  &_swigt__p_FIX__ForexReq,
  &_swigt__p_FIX__FundRenewWaiv,
  &_swigt__p_FIX__FutSettDate,
  &_swigt__p_FIX__FutSettDate2,
  &_swigt__p_FIX__FuturesValuationMethod,
  &_swigt__p_FIX__GTBookingInst,
  &_swigt__p_FIX__GapFillFlag,
  &_swigt__p_FIX__GrossTradeAmt,
  &_swigt__p_FIX__Group,
  &_swigt__p_FIX__HaltReasonChar,
  &_swigt__p_FIX__HaltReasonInt,
  &_swigt__p_FIX__HandlInst,
  &_swigt__p_FIX__Header,
  &_swigt__p_FIX__Headline,
  &_swigt__p_FIX__HeartBtInt,
  &_swigt__p_FIX__HighLimitPrice,
  &_swigt__p_FIX__HighPx,
  &_swigt__p_FIX__HopCompID,
  &_swigt__p_FIX__HopRefID,
  &_swigt__p_FIX__HopSendingTime,
  &_swigt__p_FIX__HostCrossID,
  &_swigt__p_FIX__IDSource,
  &_swigt__p_FIX__INT,
  &_swigt__p_FIX__IOException,
  &_swigt__p_FIX__IOIID,
  &_swigt__p_FIX__IOINaturalFlag,
  &_swigt__p_FIX__IOIOthSvc,
  &_swigt__p_FIX__IOIQltyInd,
  &_swigt__p_FIX__IOIQty,
  &_swigt__p_FIX__IOIQualifier,
  &_swigt__p_FIX__IOIRefID,
  &_swigt__p_FIX__IOIShares,
  &_swigt__p_FIX__IOITransType,
  &_swigt__p_FIX__IOIid,
  &_swigt__p_FIX__ImpliedMarketIndicator,
  &_swigt__p_FIX__InViewOfCommon,
  &_swigt__p_FIX__IncTaxInd,
  &_swigt__p_FIX__IncorrectDataFormat,
  &_swigt__p_FIX__IncorrectMessageStructure,
  &_swigt__p_FIX__IncorrectTagValue,
  &_swigt__p_FIX__IndividualAllocID,
  &_swigt__p_FIX__IndividualAllocRejCode,
  &_swigt__p_FIX__IndividualAllocType,
  &_swigt__p_FIX__Initiator,
  &_swigt__p_FIX__InputSource,
  &_swigt__p_FIX__InstrAttribType,
  &_swigt__p_FIX__InstrAttribValue,
  &_swigt__p_FIX__InstrRegistry,
  &_swigt__p_FIX__InstrmtAssignmentMethod,
  &_swigt__p_FIX__InstrumentPartyID,
  &_swigt__p_FIX__InstrumentPartyIDSource,
  &_swigt__p_FIX__InstrumentPartyRole,
  &_swigt__p_FIX__InstrumentPartySubID,
  &_swigt__p_FIX__InstrumentPartySubIDType,
  &_swigt__p_FIX__IntField,
  &_swigt__p_FIX__InterestAccrualDate,
  &_swigt__p_FIX__InterestAtMaturity,
  &_swigt__p_FIX__InvalidMessage,
  &_swigt__p_FIX__InvalidMessageType,
  &_swigt__p_FIX__InvalidTagNumber,
  &_swigt__p_FIX__InvestorCountryOfResidence,
  &_swigt__p_FIX__IssueDate,
  &_swigt__p_FIX__Issuer,
  &_swigt__p_FIX__LANGUAGE,
  &_swigt__p_FIX__LENGTH,
  &_swigt__p_FIX__LOCALMKTDATE,
  &_swigt__p_FIX__LanguageCode,
  &_swigt__p_FIX__LastCapacity,
  &_swigt__p_FIX__LastForwardPoints,
  &_swigt__p_FIX__LastForwardPoints2,
  &_swigt__p_FIX__LastFragment,
  &_swigt__p_FIX__LastLiquidityInd,
  &_swigt__p_FIX__LastMkt,
  &_swigt__p_FIX__LastMsgSeqNumProcessed,
  &_swigt__p_FIX__LastNetworkResponseID,
  &_swigt__p_FIX__LastParPx,
  &_swigt__p_FIX__LastPx,
  &_swigt__p_FIX__LastQty,
  &_swigt__p_FIX__LastRptRequested,
  &_swigt__p_FIX__LastShares,
  &_swigt__p_FIX__LastSpotRate,
  &_swigt__p_FIX__LastSwapPoints,
  &_swigt__p_FIX__LastUpdateTime,
  &_swigt__p_FIX__LateIndicator,
  &_swigt__p_FIX__LeavesQty,
  &_swigt__p_FIX__LegAllocAccount,
  &_swigt__p_FIX__LegAllocAcctIDSource,
  &_swigt__p_FIX__LegAllocID,
  &_swigt__p_FIX__LegAllocQty,
  &_swigt__p_FIX__LegAllocSettlCurrency,
  &_swigt__p_FIX__LegBenchmarkCurveCurrency,
  &_swigt__p_FIX__LegBenchmarkCurveName,
  &_swigt__p_FIX__LegBenchmarkCurvePoint,
  &_swigt__p_FIX__LegBenchmarkPrice,
  &_swigt__p_FIX__LegBenchmarkPriceType,
  &_swigt__p_FIX__LegBidForwardPoints,
  &_swigt__p_FIX__LegBidPx,
  &_swigt__p_FIX__LegCFICode,
  &_swigt__p_FIX__LegCalculatedCcyLastQty,
  &_swigt__p_FIX__LegContractMultiplier,
  &_swigt__p_FIX__LegContractMultiplierUnit,
  &_swigt__p_FIX__LegContractSettlMonth,
  &_swigt__p_FIX__LegCountryOfIssue,
  &_swigt__p_FIX__LegCouponPaymentDate,
  &_swigt__p_FIX__LegCouponRate,
  &_swigt__p_FIX__LegCoveredOrUncovered,
  &_swigt__p_FIX__LegCreditRating,
  &_swigt__p_FIX__LegCurrency,
  &_swigt__p_FIX__LegCurrencyRatio,
  &_swigt__p_FIX__LegDatedDate,
  &_swigt__p_FIX__LegDividendYield,
  &_swigt__p_FIX__LegExecInst,
  &_swigt__p_FIX__LegExerciseStyle,
  &_swigt__p_FIX__LegFactor,
  &_swigt__p_FIX__LegFlowScheduleType,
  &_swigt__p_FIX__LegFutSettDate,
  &_swigt__p_FIX__LegGrossTradeAmt,
  &_swigt__p_FIX__LegIOIQty,
  &_swigt__p_FIX__LegIndividualAllocID,
  &_swigt__p_FIX__LegInstrRegistry,
  &_swigt__p_FIX__LegInterestAccrualDate,
  &_swigt__p_FIX__LegIssueDate,
  &_swigt__p_FIX__LegIssuer,
  &_swigt__p_FIX__LegLastForwardPoints,
  &_swigt__p_FIX__LegLastPx,
  &_swigt__p_FIX__LegLastQty,
  &_swigt__p_FIX__LegLocaleOfIssue,
  &_swigt__p_FIX__LegMaturityDate,
  &_swigt__p_FIX__LegMaturityMonthYear,
  &_swigt__p_FIX__LegMaturityTime,
  &_swigt__p_FIX__LegNumber,
  &_swigt__p_FIX__LegOfferForwardPoints,
  &_swigt__p_FIX__LegOfferPx,
  &_swigt__p_FIX__LegOptAttribute,
  &_swigt__p_FIX__LegOptionRatio,
  &_swigt__p_FIX__LegOrderQty,
  &_swigt__p_FIX__LegPool,
  &_swigt__p_FIX__LegPositionEffect,
  &_swigt__p_FIX__LegPrice,
  &_swigt__p_FIX__LegPriceType,
  &_swigt__p_FIX__LegPriceUnitOfMeasure,
  &_swigt__p_FIX__LegPriceUnitOfMeasureQty,
  &_swigt__p_FIX__LegProduct,
  &_swigt__p_FIX__LegPutOrCall,
  &_swigt__p_FIX__LegQty,
  &_swigt__p_FIX__LegRatioQty,
  &_swigt__p_FIX__LegRedemptionDate,
  &_swigt__p_FIX__LegRefID,
  &_swigt__p_FIX__LegRepoCollateralSecurityType,
  &_swigt__p_FIX__LegReportID,
  &_swigt__p_FIX__LegRepurchaseRate,
  &_swigt__p_FIX__LegRepurchaseTerm,
  &_swigt__p_FIX__LegSecurityAltID,
  &_swigt__p_FIX__LegSecurityAltIDSource,
  &_swigt__p_FIX__LegSecurityDesc,
  &_swigt__p_FIX__LegSecurityExchange,
  &_swigt__p_FIX__LegSecurityID,
  &_swigt__p_FIX__LegSecurityIDSource,
  &_swigt__p_FIX__LegSecuritySubType,
  &_swigt__p_FIX__LegSecurityType,
  &_swigt__p_FIX__LegSettlCurrency,
  &_swigt__p_FIX__LegSettlDate,
  &_swigt__p_FIX__LegSettlType,
  &_swigt__p_FIX__LegSettlmntTyp,
  &_swigt__p_FIX__LegSide,
  &_swigt__p_FIX__LegStateOrProvinceOfIssue,
  &_swigt__p_FIX__LegStipulationType,
  &_swigt__p_FIX__LegStipulationValue,
  &_swigt__p_FIX__LegStrikeCurrency,
  &_swigt__p_FIX__LegStrikePrice,
  &_swigt__p_FIX__LegSwapType,
  &_swigt__p_FIX__LegSymbol,
  &_swigt__p_FIX__LegSymbolSfx,
  &_swigt__p_FIX__LegTimeUnit,
  &_swigt__p_FIX__LegUnitOfMeasure,
  &_swigt__p_FIX__LegUnitOfMeasureQty,
  &_swigt__p_FIX__LegVolatility,
  &_swigt__p_FIX__LegalConfirm,
  &_swigt__p_FIX__LinesOfText,
  &_swigt__p_FIX__LiquidityIndType,
  &_swigt__p_FIX__LiquidityNumSecurities,
  &_swigt__p_FIX__LiquidityPctHigh,
  &_swigt__p_FIX__LiquidityPctLow,
  &_swigt__p_FIX__LiquidityValue,
  &_swigt__p_FIX__ListExecInst,
  &_swigt__p_FIX__ListExecInstType,
  &_swigt__p_FIX__ListID,
  &_swigt__p_FIX__ListMethod,
  &_swigt__p_FIX__ListName,
  &_swigt__p_FIX__ListNoOrds,
  &_swigt__p_FIX__ListOrderStatus,
  &_swigt__p_FIX__ListRejectReason,
  &_swigt__p_FIX__ListSeqNo,
  &_swigt__p_FIX__ListStatusText,
  &_swigt__p_FIX__ListStatusType,
  &_swigt__p_FIX__ListUpdateAction,
  &_swigt__p_FIX__LocaleOfIssue,
  &_swigt__p_FIX__LocateReqd,
  &_swigt__p_FIX__LocationID,
  &_swigt__p_FIX__Log,
  &_swigt__p_FIX__LogFactory,
  &_swigt__p_FIX__LongQty,
  &_swigt__p_FIX__LotType,
  &_swigt__p_FIX__LowLimitPrice,
  &_swigt__p_FIX__LowPx,
  &_swigt__p_FIX__MDBookType,
  &_swigt__p_FIX__MDEntryBuyer,
  &_swigt__p_FIX__MDEntryDate,
  &_swigt__p_FIX__MDEntryForwardPoints,
  &_swigt__p_FIX__MDEntryID,
  &_swigt__p_FIX__MDEntryOriginator,
  &_swigt__p_FIX__MDEntryPositionNo,
  &_swigt__p_FIX__MDEntryPx,
  &_swigt__p_FIX__MDEntryRefID,
  &_swigt__p_FIX__MDEntrySeller,
  &_swigt__p_FIX__MDEntrySize,
  &_swigt__p_FIX__MDEntrySpotRate,
  &_swigt__p_FIX__MDEntryTime,
  &_swigt__p_FIX__MDEntryType,
  &_swigt__p_FIX__MDFeedType,
  &_swigt__p_FIX__MDImplicitDelete,
  &_swigt__p_FIX__MDMkt,
  &_swigt__p_FIX__MDOriginType,
  &_swigt__p_FIX__MDPriceLevel,
  &_swigt__p_FIX__MDQuoteType,
  &_swigt__p_FIX__MDReportID,
  &_swigt__p_FIX__MDReqID,
  &_swigt__p_FIX__MDReqRejReason,
  &_swigt__p_FIX__MDSecSize,
  &_swigt__p_FIX__MDSecSizeType,
  &_swigt__p_FIX__MDStreamID,
  &_swigt__p_FIX__MDSubBookType,
  &_swigt__p_FIX__MDUpdateAction,
  &_swigt__p_FIX__MDUpdateType,
  &_swigt__p_FIX__MONTHYEAR,
  &_swigt__p_FIX__MULTIPLECHARVALUE,
  &_swigt__p_FIX__MULTIPLESTRINGVALUE,
  &_swigt__p_FIX__MULTIPLEVALUESTRING,
  &_swigt__p_FIX__MailingDtls,
  &_swigt__p_FIX__MailingInst,
  &_swigt__p_FIX__ManualOrderIndicator,
  &_swigt__p_FIX__MarginExcess,
  &_swigt__p_FIX__MarginRatio,
  &_swigt__p_FIX__MarketDepth,
  &_swigt__p_FIX__MarketID,
  &_swigt__p_FIX__MarketReportID,
  &_swigt__p_FIX__MarketReqID,
  &_swigt__p_FIX__MarketSegmentDesc,
  &_swigt__p_FIX__MarketSegmentID,
  &_swigt__p_FIX__MarketUpdateAction,
  &_swigt__p_FIX__MassActionRejectReason,
  &_swigt__p_FIX__MassActionReportID,
  &_swigt__p_FIX__MassActionResponse,
  &_swigt__p_FIX__MassActionScope,
  &_swigt__p_FIX__MassActionType,
  &_swigt__p_FIX__MassCancelRejectReason,
  &_swigt__p_FIX__MassCancelRequestType,
  &_swigt__p_FIX__MassCancelResponse,
  &_swigt__p_FIX__MassStatusReqID,
  &_swigt__p_FIX__MassStatusReqType,
  &_swigt__p_FIX__MatchAlgorithm,
  &_swigt__p_FIX__MatchIncrement,
  &_swigt__p_FIX__MatchStatus,
  &_swigt__p_FIX__MatchType,
  &_swigt__p_FIX__MaturityDate,
  &_swigt__p_FIX__MaturityDay,
  &_swigt__p_FIX__MaturityMonthYear,
  &_swigt__p_FIX__MaturityMonthYearFormat,
  &_swigt__p_FIX__MaturityMonthYearIncrement,
  &_swigt__p_FIX__MaturityMonthYearIncrementUnits,
  &_swigt__p_FIX__MaturityNetMoney,
  &_swigt__p_FIX__MaturityRuleID,
  &_swigt__p_FIX__MaturityTime,
  &_swigt__p_FIX__MaxFloor,
  &_swigt__p_FIX__MaxMessageSize,
  &_swigt__p_FIX__MaxPriceLevels,
  &_swigt__p_FIX__MaxPriceVariation,
  &_swigt__p_FIX__MaxShow,
  &_swigt__p_FIX__MaxTradeVol,
  &_swigt__p_FIX__MemoryStore,
  &_swigt__p_FIX__MemoryStoreFactory,
  &_swigt__p_FIX__Message,
  &_swigt__p_FIX__MessageEncoding,
  &_swigt__p_FIX__MessageEventSource,
  &_swigt__p_FIX__MessageParseError,
  &_swigt__p_FIX__MessageStore,
  &_swigt__p_FIX__MessageStoreExceptionWrapper,
  &_swigt__p_FIX__MessageStoreFactory,
  &_swigt__p_FIX__MessageStoreFactoryExceptionWrapper,
  &_swigt__p_FIX__MidPx,
  &_swigt__p_FIX__MidYield,
  &_swigt__p_FIX__MinBidSize,
  &_swigt__p_FIX__MinLotSize,
  &_swigt__p_FIX__MinOfferSize,
  &_swigt__p_FIX__MinPriceIncrement,
  &_swigt__p_FIX__MinPriceIncrementAmount,
  &_swigt__p_FIX__MinQty,
  &_swigt__p_FIX__MinTradeVol,
  &_swigt__p_FIX__MiscFeeAmt,
  &_swigt__p_FIX__MiscFeeBasis,
  &_swigt__p_FIX__MiscFeeCurr,
  &_swigt__p_FIX__MiscFeeType,
  &_swigt__p_FIX__MktBidPx,
  &_swigt__p_FIX__MktOfferPx,
  &_swigt__p_FIX__ModelType,
  &_swigt__p_FIX__MoneyLaunderingStatus,
  &_swigt__p_FIX__MsgDirection,
  &_swigt__p_FIX__MsgSeqNum,
  &_swigt__p_FIX__MsgType,
  &_swigt__p_FIX__MultiLegReportingType,
  &_swigt__p_FIX__MultiLegRptTypeReq,
  &_swigt__p_FIX__MultilegModel,
  &_swigt__p_FIX__MultilegPriceMethod,
  &_swigt__p_FIX__NTPositionLimit,
  &_swigt__p_FIX__NUMINGROUP,
  &_swigt__p_FIX__Nested2PartyID,
  &_swigt__p_FIX__Nested2PartyIDSource,
  &_swigt__p_FIX__Nested2PartyRole,
  &_swigt__p_FIX__Nested2PartySubID,
  &_swigt__p_FIX__Nested2PartySubIDType,
  &_swigt__p_FIX__Nested3PartyID,
  &_swigt__p_FIX__Nested3PartyIDSource,
  &_swigt__p_FIX__Nested3PartyRole,
  &_swigt__p_FIX__Nested3PartySubID,
  &_swigt__p_FIX__Nested3PartySubIDType,
  &_swigt__p_FIX__Nested4PartyID,
  &_swigt__p_FIX__Nested4PartyIDSource,
  &_swigt__p_FIX__Nested4PartyRole,
  &_swigt__p_FIX__Nested4PartySubID,
  &_swigt__p_FIX__Nested4PartySubIDType,
  &_swigt__p_FIX__NestedInstrAttribType,
  &_swigt__p_FIX__NestedInstrAttribValue,
  &_swigt__p_FIX__NestedPartyID,
  &_swigt__p_FIX__NestedPartyIDSource,
  &_swigt__p_FIX__NestedPartyRole,
  &_swigt__p_FIX__NestedPartySubID,
  &_swigt__p_FIX__NestedPartySubIDType,
  &_swigt__p_FIX__NetChgPrevDay,
  &_swigt__p_FIX__NetGrossInd,
  &_swigt__p_FIX__NetMoney,
  &_swigt__p_FIX__NetworkRequestID,
  &_swigt__p_FIX__NetworkRequestType,
  &_swigt__p_FIX__NetworkResponseID,
  &_swigt__p_FIX__NetworkStatusResponseType,
  &_swigt__p_FIX__NewPassword,
  &_swigt__p_FIX__NewSeqNo,
  &_swigt__p_FIX__NewsCategory,
  &_swigt__p_FIX__NewsID,
  &_swigt__p_FIX__NewsRefID,
  &_swigt__p_FIX__NewsRefType,
  &_swigt__p_FIX__NextExpectedMsgSeqNum,
  &_swigt__p_FIX__NoAffectedOrders,
  &_swigt__p_FIX__NoAllocs,
  &_swigt__p_FIX__NoAltMDSource,
  &_swigt__p_FIX__NoApplIDs,
  &_swigt__p_FIX__NoAsgnReqs,
  &_swigt__p_FIX__NoBidComponents,
  &_swigt__p_FIX__NoBidDescriptors,
  &_swigt__p_FIX__NoCapacities,
  &_swigt__p_FIX__NoClearingInstructions,
  &_swigt__p_FIX__NoCollInquiryQualifier,
  &_swigt__p_FIX__NoCompIDs,
  &_swigt__p_FIX__NoComplexEventDates,
  &_swigt__p_FIX__NoComplexEventTimes,
  &_swigt__p_FIX__NoComplexEvents,
  &_swigt__p_FIX__NoContAmts,
  &_swigt__p_FIX__NoContraBrokers,
  &_swigt__p_FIX__NoDates,
  &_swigt__p_FIX__NoDerivativeEvents,
  &_swigt__p_FIX__NoDerivativeInstrAttrib,
  &_swigt__p_FIX__NoDerivativeInstrumentParties,
  &_swigt__p_FIX__NoDerivativeInstrumentPartySubIDs,
  &_swigt__p_FIX__NoDerivativeSecurityAltID,
  &_swigt__p_FIX__NoDistribInsts,
  &_swigt__p_FIX__NoDlvyInst,
  &_swigt__p_FIX__NoEvents,
  &_swigt__p_FIX__NoExecInstRules,
  &_swigt__p_FIX__NoExecs,
  &_swigt__p_FIX__NoExpiration,
  &_swigt__p_FIX__NoFills,
  &_swigt__p_FIX__NoHops,
  &_swigt__p_FIX__NoIOIQualifiers,
  &_swigt__p_FIX__NoInstrAttrib,
  &_swigt__p_FIX__NoInstrumentParties,
  &_swigt__p_FIX__NoInstrumentPartySubIDs,
  &_swigt__p_FIX__NoLegAllocs,
  &_swigt__p_FIX__NoLegSecurityAltID,
  &_swigt__p_FIX__NoLegStipulations,
  &_swigt__p_FIX__NoLegs,
  &_swigt__p_FIX__NoLinesOfText,
  &_swigt__p_FIX__NoLotTypeRules,
  &_swigt__p_FIX__NoMDEntries,
  &_swigt__p_FIX__NoMDEntryTypes,
  &_swigt__p_FIX__NoMDFeedTypes,
  &_swigt__p_FIX__NoMarketSegments,
  &_swigt__p_FIX__NoMatchRules,
  &_swigt__p_FIX__NoMaturityRules,
  &_swigt__p_FIX__NoMiscFees,
  &_swigt__p_FIX__NoMsgTypes,
  &_swigt__p_FIX__NoNested2PartyIDs,
  &_swigt__p_FIX__NoNested2PartySubIDs,
  &_swigt__p_FIX__NoNested3PartyIDs,
  &_swigt__p_FIX__NoNested3PartySubIDs,
  &_swigt__p_FIX__NoNested4PartyIDs,
  &_swigt__p_FIX__NoNested4PartySubIDs,
  &_swigt__p_FIX__NoNestedInstrAttrib,
  &_swigt__p_FIX__NoNestedPartyIDs,
  &_swigt__p_FIX__NoNestedPartySubIDs,
  &_swigt__p_FIX__NoNewsRefIDs,
  &_swigt__p_FIX__NoNotAffectedOrders,
  &_swigt__p_FIX__NoOfLegUnderlyings,
  &_swigt__p_FIX__NoOfSecSizes,
  &_swigt__p_FIX__NoOrdTypeRules,
  &_swigt__p_FIX__NoOrders,
  &_swigt__p_FIX__NoPartyIDs,
  &_swigt__p_FIX__NoPartySubIDs,
  &_swigt__p_FIX__NoPosAmt,
  &_swigt__p_FIX__NoPositions,
  &_swigt__p_FIX__NoQuoteEntries,
  &_swigt__p_FIX__NoQuoteQualifiers,
  &_swigt__p_FIX__NoQuoteSets,
  &_swigt__p_FIX__NoRateSources,
  &_swigt__p_FIX__NoRegistDtls,
  &_swigt__p_FIX__NoRelatedSym,
  &_swigt__p_FIX__NoRootPartyIDs,
  &_swigt__p_FIX__NoRootPartySubIDs,
  &_swigt__p_FIX__NoRoutingIDs,
  &_swigt__p_FIX__NoRpts,
  &_swigt__p_FIX__NoSecurityAltID,
  &_swigt__p_FIX__NoSecurityTypes,
  &_swigt__p_FIX__NoSettlDetails,
  &_swigt__p_FIX__NoSettlInst,
  &_swigt__p_FIX__NoSettlOblig,
  &_swigt__p_FIX__NoSettlPartyIDs,
  &_swigt__p_FIX__NoSettlPartySubIDs,
  &_swigt__p_FIX__NoSideTrdRegTS,
  &_swigt__p_FIX__NoSides,
  &_swigt__p_FIX__NoStatsIndicators,
  &_swigt__p_FIX__NoStipulations,
  &_swigt__p_FIX__NoStrategyParameters,
  &_swigt__p_FIX__NoStrikeRules,
  &_swigt__p_FIX__NoStrikes,
  &_swigt__p_FIX__NoTagValue,
  &_swigt__p_FIX__NoTargetPartyIDs,
  &_swigt__p_FIX__NoTickRules,
  &_swigt__p_FIX__NoTimeInForceRules,
  &_swigt__p_FIX__NoTrades,
  &_swigt__p_FIX__NoTradingSessionRules,
  &_swigt__p_FIX__NoTradingSessions,
  &_swigt__p_FIX__NoTrdRegTimestamps,
  &_swigt__p_FIX__NoTrdRepIndicators,
  &_swigt__p_FIX__NoUnderlyingAmounts,
  &_swigt__p_FIX__NoUnderlyingLegSecurityAltID,
  &_swigt__p_FIX__NoUnderlyingSecurityAltID,
  &_swigt__p_FIX__NoUnderlyingStips,
  &_swigt__p_FIX__NoUnderlyings,
  &_swigt__p_FIX__NoUndlyInstrumentParties,
  &_swigt__p_FIX__NoUndlyInstrumentPartySubIDs,
  &_swigt__p_FIX__NotAffOrigClOrdID,
  &_swigt__p_FIX__NotAffectedOrderID,
  &_swigt__p_FIX__NotifyBrokerOfCredit,
  &_swigt__p_FIX__NotionalPercentageOutstanding,
  &_swigt__p_FIX__NullApplication,
  &_swigt__p_FIX__NullLog,
  &_swigt__p_FIX__NumBidders,
  &_swigt__p_FIX__NumDaysInterest,
  &_swigt__p_FIX__NumTickets,
  &_swigt__p_FIX__NumberOfOrders,
  &_swigt__p_FIX__OddLot,
  &_swigt__p_FIX__OfferForwardPoints,
  &_swigt__p_FIX__OfferForwardPoints2,
  &_swigt__p_FIX__OfferPx,
  &_swigt__p_FIX__OfferSize,
  &_swigt__p_FIX__OfferSpotRate,
  &_swigt__p_FIX__OfferSwapPoints,
  &_swigt__p_FIX__OfferYield,
  &_swigt__p_FIX__OnBehalfOfCompID,
  &_swigt__p_FIX__OnBehalfOfLocationID,
  &_swigt__p_FIX__OnBehalfOfSendingTime,
  &_swigt__p_FIX__OnBehalfOfSubID,
  &_swigt__p_FIX__OpenClose,
  &_swigt__p_FIX__OpenCloseSettlFlag,
  &_swigt__p_FIX__OpenCloseSettleFlag,
  &_swigt__p_FIX__OpenInterest,
  &_swigt__p_FIX__OptAttribute,
  &_swigt__p_FIX__OptPayAmount,
  &_swigt__p_FIX__OptPayoutAmount,
  &_swigt__p_FIX__OptPayoutType,
  &_swigt__p_FIX__OrdRejReason,
  &_swigt__p_FIX__OrdStatus,
  &_swigt__p_FIX__OrdStatusReqID,
  &_swigt__p_FIX__OrdType,
  &_swigt__p_FIX__OrderAvgPx,
  &_swigt__p_FIX__OrderBookingQty,
  &_swigt__p_FIX__OrderCapacity,
  &_swigt__p_FIX__OrderCapacityQty,
  &_swigt__p_FIX__OrderCategory,
  &_swigt__p_FIX__OrderDelay,
  &_swigt__p_FIX__OrderDelayUnit,
  &_swigt__p_FIX__OrderHandlingInstSource,
  &_swigt__p_FIX__OrderID,
  &_swigt__p_FIX__OrderInputDevice,
  &_swigt__p_FIX__OrderPercent,
  &_swigt__p_FIX__OrderQty,
  &_swigt__p_FIX__OrderQty2,
  &_swigt__p_FIX__OrderRestrictions,
  &_swigt__p_FIX__OrigClOrdID,
  &_swigt__p_FIX__OrigCrossID,
  &_swigt__p_FIX__OrigCustOrderCapacity,
  &_swigt__p_FIX__OrigOrdModTime,
  &_swigt__p_FIX__OrigPosReqRefID,
  &_swigt__p_FIX__OrigSecondaryTradeID,
  &_swigt__p_FIX__OrigSendingTime,
  &_swigt__p_FIX__OrigTime,
  &_swigt__p_FIX__OrigTradeDate,
  &_swigt__p_FIX__OrigTradeHandlingInstr,
  &_swigt__p_FIX__OrigTradeID,
  &_swigt__p_FIX__OriginalNotionalPercentageOutstanding,
  &_swigt__p_FIX__OutMainCntryUIndex,
  &_swigt__p_FIX__OutsideIndexPct,
  &_swigt__p_FIX__OwnerType,
  &_swigt__p_FIX__OwnershipType,
  &_swigt__p_FIX__PERCENTAGE,
  &_swigt__p_FIX__PRICE,
  &_swigt__p_FIX__PRICEOFFSET,
  &_swigt__p_FIX__ParentMktSegmID,
  &_swigt__p_FIX__ParticipationRate,
  &_swigt__p_FIX__PartyID,
  &_swigt__p_FIX__PartyIDSource,
  &_swigt__p_FIX__PartyRole,
  &_swigt__p_FIX__PartySubID,
  &_swigt__p_FIX__PartySubIDType,
  &_swigt__p_FIX__Password,
  &_swigt__p_FIX__PaymentDate,
  &_swigt__p_FIX__PaymentMethod,
  &_swigt__p_FIX__PaymentRef,
  &_swigt__p_FIX__PaymentRemitterID,
  &_swigt__p_FIX__PctAtRisk,
  &_swigt__p_FIX__PegDifference,
  &_swigt__p_FIX__PegLimitType,
  &_swigt__p_FIX__PegMoveType,
  &_swigt__p_FIX__PegOffsetType,
  &_swigt__p_FIX__PegOffsetValue,
  &_swigt__p_FIX__PegPriceType,
  &_swigt__p_FIX__PegRoundDirection,
  &_swigt__p_FIX__PegScope,
  &_swigt__p_FIX__PegSecurityDesc,
  &_swigt__p_FIX__PegSecurityID,
  &_swigt__p_FIX__PegSecurityIDSource,
  &_swigt__p_FIX__PegSymbol,
  &_swigt__p_FIX__PeggedPrice,
  &_swigt__p_FIX__PeggedRefPrice,
  &_swigt__p_FIX__Pool,
  &_swigt__p_FIX__PosAmt,
  &_swigt__p_FIX__PosAmtType,
  &_swigt__p_FIX__PosMaintAction,
  &_swigt__p_FIX__PosMaintResult,
  &_swigt__p_FIX__PosMaintRptID,
  &_swigt__p_FIX__PosMaintRptRefID,
  &_swigt__p_FIX__PosMaintStatus,
  &_swigt__p_FIX__PosQtyStatus,
  &_swigt__p_FIX__PosReqID,
  &_swigt__p_FIX__PosReqResult,
  &_swigt__p_FIX__PosReqStatus,
  &_swigt__p_FIX__PosReqType,
  &_swigt__p_FIX__PosTransType,
  &_swigt__p_FIX__PosType,
  &_swigt__p_FIX__PositionCurrency,
  &_swigt__p_FIX__PositionEffect,
  &_swigt__p_FIX__PositionLimit,
  &_swigt__p_FIX__PossDupFlag,
  &_swigt__p_FIX__PossResend,
  &_swigt__p_FIX__PreTradeAnonymity,
  &_swigt__p_FIX__PreallocMethod,
  &_swigt__p_FIX__PrevClosePx,
  &_swigt__p_FIX__PreviouslyReported,
  &_swigt__p_FIX__Price,
  &_swigt__p_FIX__Price2,
  &_swigt__p_FIX__PriceDelta,
  &_swigt__p_FIX__PriceImprovement,
  &_swigt__p_FIX__PriceLimitType,
  &_swigt__p_FIX__PriceProtectionScope,
  &_swigt__p_FIX__PriceQuoteMethod,
  &_swigt__p_FIX__PriceType,
  &_swigt__p_FIX__PriceUnitOfMeasure,
  &_swigt__p_FIX__PriceUnitOfMeasureQty,
  &_swigt__p_FIX__PriorSettlPrice,
  &_swigt__p_FIX__PriorSpreadIndicator,
  &_swigt__p_FIX__PriorityIndicator,
  &_swigt__p_FIX__PrivateQuote,
  &_swigt__p_FIX__ProcessCode,
  &_swigt__p_FIX__Product,
  &_swigt__p_FIX__ProductComplex,
  &_swigt__p_FIX__ProgPeriodInterval,
  &_swigt__p_FIX__ProgRptReqs,
  &_swigt__p_FIX__PublishTrdIndicator,
  &_swigt__p_FIX__PutOrCall,
  &_swigt__p_FIX__QTY,
  &_swigt__p_FIX__QtyType,
  &_swigt__p_FIX__Quantity,
  &_swigt__p_FIX__QuantityDate,
  &_swigt__p_FIX__QuantityType,
  &_swigt__p_FIX__QuoteAckStatus,
  &_swigt__p_FIX__QuoteCancelType,
  &_swigt__p_FIX__QuoteCondition,
  &_swigt__p_FIX__QuoteEntryID,
  &_swigt__p_FIX__QuoteEntryRejectReason,
  &_swigt__p_FIX__QuoteEntryStatus,
  &_swigt__p_FIX__QuoteID,
  &_swigt__p_FIX__QuoteMsgID,
  &_swigt__p_FIX__QuotePriceType,
  &_swigt__p_FIX__QuoteQualifier,
  &_swigt__p_FIX__QuoteRejectReason,
  &_swigt__p_FIX__QuoteReqID,
  &_swigt__p_FIX__QuoteRequestRejectReason,
  &_swigt__p_FIX__QuoteRequestType,
  &_swigt__p_FIX__QuoteRespID,
  &_swigt__p_FIX__QuoteRespType,
  &_swigt__p_FIX__QuoteResponseLevel,
  &_swigt__p_FIX__QuoteSetID,
  &_swigt__p_FIX__QuoteSetValidUntilTime,
  &_swigt__p_FIX__QuoteStatus,
  &_swigt__p_FIX__QuoteStatusReqID,
  &_swigt__p_FIX__QuoteType,
  &_swigt__p_FIX__RFQReqID,
  &_swigt__p_FIX__RateSource,
  &_swigt__p_FIX__RateSourceType,
  &_swigt__p_FIX__RatioQty,
  &_swigt__p_FIX__RawData,
  &_swigt__p_FIX__RawDataLength,
  &_swigt__p_FIX__ReceivedDeptID,
  &_swigt__p_FIX__RedemptionDate,
  &_swigt__p_FIX__RefAllocID,
  &_swigt__p_FIX__RefApplExtID,
  &_swigt__p_FIX__RefApplID,
  &_swigt__p_FIX__RefApplLastSeqNum,
  &_swigt__p_FIX__RefApplReqID,
  &_swigt__p_FIX__RefApplVerID,
  &_swigt__p_FIX__RefCompID,
  &_swigt__p_FIX__RefCstmApplVerID,
  &_swigt__p_FIX__RefMsgType,
  &_swigt__p_FIX__RefOrdIDReason,
  &_swigt__p_FIX__RefOrderID,
  &_swigt__p_FIX__RefOrderIDSource,
  &_swigt__p_FIX__RefSeqNum,
  &_swigt__p_FIX__RefSubID,
  &_swigt__p_FIX__RefTagID,
  &_swigt__p_FIX__ReferencePage,
  &_swigt__p_FIX__RefreshIndicator,
  &_swigt__p_FIX__RefreshQty,
  &_swigt__p_FIX__RegistAcctType,
  &_swigt__p_FIX__RegistDetls,
  &_swigt__p_FIX__RegistDtls,
  &_swigt__p_FIX__RegistEmail,
  &_swigt__p_FIX__RegistID,
  &_swigt__p_FIX__RegistRefID,
  &_swigt__p_FIX__RegistRejReasonCode,
  &_swigt__p_FIX__RegistRejReasonText,
  &_swigt__p_FIX__RegistStatus,
  &_swigt__p_FIX__RegistTransType,
  &_swigt__p_FIX__RejectLogon,
  &_swigt__p_FIX__RejectText,
  &_swigt__p_FIX__RelSymTransactTime,
  &_swigt__p_FIX__RelatdSym,
  &_swigt__p_FIX__RepeatedTag,
  &_swigt__p_FIX__RepeatingGroupCountMismatch,
  &_swigt__p_FIX__RepoCollateralSecurityType,
  &_swigt__p_FIX__ReportToExch,
  &_swigt__p_FIX__ReportedPx,
  &_swigt__p_FIX__ReportedPxDiff,
  &_swigt__p_FIX__RepurchaseRate,
  &_swigt__p_FIX__RepurchaseTerm,
  &_swigt__p_FIX__RequiredTagMissing,
  &_swigt__p_FIX__ResetSeqNumFlag,
  &_swigt__p_FIX__RespondentType,
  &_swigt__p_FIX__ResponseDestination,
  &_swigt__p_FIX__ResponseTransportType,
  &_swigt__p_FIX__RestructuringType,
  &_swigt__p_FIX__ReversalIndicator,
  &_swigt__p_FIX__RiskFreeRate,
  &_swigt__p_FIX__RndPx,
  &_swigt__p_FIX__RootPartyID,
  &_swigt__p_FIX__RootPartyIDSource,
  &_swigt__p_FIX__RootPartyRole,
  &_swigt__p_FIX__RootPartySubID,
  &_swigt__p_FIX__RootPartySubIDType,
  &_swigt__p_FIX__RoundLot,
  &_swigt__p_FIX__RoundingDirection,
  &_swigt__p_FIX__RoundingModulus,
  &_swigt__p_FIX__RoutingID,
  &_swigt__p_FIX__RoutingType,
  &_swigt__p_FIX__RptSeq,
  &_swigt__p_FIX__RptSys,
  &_swigt__p_FIX__Rule80A,
  &_swigt__p_FIX__RuntimeError,
  &_swigt__p_FIX__SEQNUM,
  &_swigt__p_FIX__STRING,
  &_swigt__p_FIX__Scope,
  &_swigt__p_FIX__ScreenLog,
  &_swigt__p_FIX__ScreenLogFactory,
  &_swigt__p_FIX__SecondaryAllocID,
  &_swigt__p_FIX__SecondaryClOrdID,
  &_swigt__p_FIX__SecondaryDisplayQty,
  &_swigt__p_FIX__SecondaryExecID,
  &_swigt__p_FIX__SecondaryFirmTradeID,
  &_swigt__p_FIX__SecondaryHighLimitPrice,
  &_swigt__p_FIX__SecondaryIndividualAllocID,
  &_swigt__p_FIX__SecondaryLowLimitPrice,
  &_swigt__p_FIX__SecondaryOrderID,
  &_swigt__p_FIX__SecondaryPriceLimitType,
  &_swigt__p_FIX__SecondaryTradeID,
  &_swigt__p_FIX__SecondaryTradeReportID,
  &_swigt__p_FIX__SecondaryTradeReportRefID,
  &_swigt__p_FIX__SecondaryTradingReferencePrice,
  &_swigt__p_FIX__SecondaryTrdType,
  &_swigt__p_FIX__SecureData,
  &_swigt__p_FIX__SecureDataLen,
  &_swigt__p_FIX__SecurityAltID,
  &_swigt__p_FIX__SecurityAltIDSource,
  &_swigt__p_FIX__SecurityDesc,
  &_swigt__p_FIX__SecurityExchange,
  &_swigt__p_FIX__SecurityGroup,
  &_swigt__p_FIX__SecurityID,
  &_swigt__p_FIX__SecurityIDSource,
  &_swigt__p_FIX__SecurityListDesc,
  &_swigt__p_FIX__SecurityListID,
  &_swigt__p_FIX__SecurityListRefID,
  &_swigt__p_FIX__SecurityListRequestType,
  &_swigt__p_FIX__SecurityListType,
  &_swigt__p_FIX__SecurityListTypeSource,
  &_swigt__p_FIX__SecurityReportID,
  &_swigt__p_FIX__SecurityReqID,
  &_swigt__p_FIX__SecurityRequestResult,
  &_swigt__p_FIX__SecurityRequestType,
  &_swigt__p_FIX__SecurityResponseID,
  &_swigt__p_FIX__SecurityResponseType,
  &_swigt__p_FIX__SecuritySettlAgentAcctName,
  &_swigt__p_FIX__SecuritySettlAgentAcctNum,
  &_swigt__p_FIX__SecuritySettlAgentCode,
  &_swigt__p_FIX__SecuritySettlAgentContactName,
  &_swigt__p_FIX__SecuritySettlAgentContactPhone,
  &_swigt__p_FIX__SecuritySettlAgentName,
  &_swigt__p_FIX__SecurityStatus,
  &_swigt__p_FIX__SecurityStatusReqID,
  &_swigt__p_FIX__SecuritySubType,
  &_swigt__p_FIX__SecurityTradingEvent,
  &_swigt__p_FIX__SecurityTradingStatus,
  &_swigt__p_FIX__SecurityType,
  &_swigt__p_FIX__SecurityUpdateAction,
  &_swigt__p_FIX__SecurityXML,
  &_swigt__p_FIX__SecurityXMLLen,
  &_swigt__p_FIX__SecurityXMLSchema,
  &_swigt__p_FIX__SellVolume,
  &_swigt__p_FIX__SellerDays,
  &_swigt__p_FIX__SenderCompID,
  &_swigt__p_FIX__SenderLocationID,
  &_swigt__p_FIX__SenderSubID,
  &_swigt__p_FIX__SendingDate,
  &_swigt__p_FIX__SendingTime,
  &_swigt__p_FIX__Seniority,
  &_swigt__p_FIX__Session,
  &_swigt__p_FIX__SessionID,
  &_swigt__p_FIX__SessionNotFound,
  &_swigt__p_FIX__SessionRejectReason,
  &_swigt__p_FIX__SessionSettings,
  &_swigt__p_FIX__SessionStatus,
  &_swigt__p_FIX__SettlBrkrCode,
  &_swigt__p_FIX__SettlCurrAmt,
  &_swigt__p_FIX__SettlCurrBidFxRate,
  &_swigt__p_FIX__SettlCurrFxRate,
  &_swigt__p_FIX__SettlCurrFxRateCalc,
  &_swigt__p_FIX__SettlCurrOfferFxRate,
  &_swigt__p_FIX__SettlCurrency,
  &_swigt__p_FIX__SettlDate,
  &_swigt__p_FIX__SettlDate2,
  &_swigt__p_FIX__SettlDeliveryType,
  &_swigt__p_FIX__SettlDepositoryCode,
  &_swigt__p_FIX__SettlInstCode,
  &_swigt__p_FIX__SettlInstID,
  &_swigt__p_FIX__SettlInstMode,
  &_swigt__p_FIX__SettlInstMsgID,
  &_swigt__p_FIX__SettlInstRefID,
  &_swigt__p_FIX__SettlInstReqID,
  &_swigt__p_FIX__SettlInstReqRejCode,
  &_swigt__p_FIX__SettlInstSource,
  &_swigt__p_FIX__SettlInstTransType,
  &_swigt__p_FIX__SettlLocation,
  &_swigt__p_FIX__SettlMethod,
  &_swigt__p_FIX__SettlObligID,
  &_swigt__p_FIX__SettlObligMode,
  &_swigt__p_FIX__SettlObligMsgID,
  &_swigt__p_FIX__SettlObligRefID,
  &_swigt__p_FIX__SettlObligSource,
  &_swigt__p_FIX__SettlObligTransType,
  &_swigt__p_FIX__SettlPartyID,
  &_swigt__p_FIX__SettlPartyIDSource,
  &_swigt__p_FIX__SettlPartyRole,
  &_swigt__p_FIX__SettlPartySubID,
  &_swigt__p_FIX__SettlPartySubIDType,
  &_swigt__p_FIX__SettlPrice,
  &_swigt__p_FIX__SettlPriceType,
  &_swigt__p_FIX__SettlSessID,
  &_swigt__p_FIX__SettlSessSubID,
  &_swigt__p_FIX__SettlType,
  &_swigt__p_FIX__SettleOnOpenFlag,
  &_swigt__p_FIX__SettlementCycleNo,
  &_swigt__p_FIX__SettlmntTyp,
  &_swigt__p_FIX__SharedCommission,
  &_swigt__p_FIX__Shares,
  &_swigt__p_FIX__ShortQty,
  &_swigt__p_FIX__ShortSaleReason,
  &_swigt__p_FIX__Side,
  &_swigt__p_FIX__SideComplianceID,
  &_swigt__p_FIX__SideCurrency,
  &_swigt__p_FIX__SideExecID,
  &_swigt__p_FIX__SideFillStationCd,
  &_swigt__p_FIX__SideGrossTradeAmt,
  &_swigt__p_FIX__SideLastQty,
  &_swigt__p_FIX__SideLiquidityInd,
  &_swigt__p_FIX__SideMultiLegReportingType,
  &_swigt__p_FIX__SideQty,
  &_swigt__p_FIX__SideReasonCd,
  &_swigt__p_FIX__SideSettlCurrency,
  &_swigt__p_FIX__SideTimeInForce,
  &_swigt__p_FIX__SideTradeReportID,
  &_swigt__p_FIX__SideTrdRegTimestamp,
  &_swigt__p_FIX__SideTrdRegTimestampSrc,
  &_swigt__p_FIX__SideTrdRegTimestampType,
  &_swigt__p_FIX__SideTrdSubTyp,
  &_swigt__p_FIX__SideValue1,
  &_swigt__p_FIX__SideValue2,
  &_swigt__p_FIX__SideValueInd,
  &_swigt__p_FIX__Signature,
  &_swigt__p_FIX__SignatureLength,
  &_swigt__p_FIX__SocketAcceptor,
  &_swigt__p_FIX__SocketCloseFailed,
  &_swigt__p_FIX__SocketException,
  &_swigt__p_FIX__SocketInitiator,
  &_swigt__p_FIX__SocketRecvFailed,
  &_swigt__p_FIX__SocketSendFailed,
  &_swigt__p_FIX__SolicitedFlag,
  &_swigt__p_FIX__Spread,
  &_swigt__p_FIX__SpreadToBenchmark,
  &_swigt__p_FIX__StandInstDbID,
  &_swigt__p_FIX__StandInstDbName,
  &_swigt__p_FIX__StandInstDbType,
  &_swigt__p_FIX__StartCash,
  &_swigt__p_FIX__StartDate,
  &_swigt__p_FIX__StartMaturityMonthYear,
  &_swigt__p_FIX__StartStrikePxRange,
  &_swigt__p_FIX__StartTickPriceRange,
  &_swigt__p_FIX__StateOrProvinceOfIssue,
  &_swigt__p_FIX__StatsType,
  &_swigt__p_FIX__StatusText,
  &_swigt__p_FIX__StatusValue,
  &_swigt__p_FIX__StipulationType,
  &_swigt__p_FIX__StipulationValue,
  &_swigt__p_FIX__StopPx,
  &_swigt__p_FIX__StrategyParameterName,
  &_swigt__p_FIX__StrategyParameterType,
  &_swigt__p_FIX__StrategyParameterValue,
  &_swigt__p_FIX__StreamAsgnAckType,
  &_swigt__p_FIX__StreamAsgnRejReason,
  &_swigt__p_FIX__StreamAsgnReqID,
  &_swigt__p_FIX__StreamAsgnReqType,
  &_swigt__p_FIX__StreamAsgnRptID,
  &_swigt__p_FIX__StreamAsgnType,
  &_swigt__p_FIX__StrikeCurrency,
  &_swigt__p_FIX__StrikeExerciseStyle,
  &_swigt__p_FIX__StrikeIncrement,
  &_swigt__p_FIX__StrikeMultiplier,
  &_swigt__p_FIX__StrikePrice,
  &_swigt__p_FIX__StrikePriceBoundaryMethod,
  &_swigt__p_FIX__StrikePriceBoundaryPrecision,
  &_swigt__p_FIX__StrikePriceDeterminationMethod,
  &_swigt__p_FIX__StrikeRuleID,
  &_swigt__p_FIX__StrikeTime,
  &_swigt__p_FIX__StrikeValue,
  &_swigt__p_FIX__StringField,
  &_swigt__p_FIX__Subject,
  &_swigt__p_FIX__SubscriptionRequestType,
  &_swigt__p_FIX__SwapPoints,
  &_swigt__p_FIX__Symbol,
  &_swigt__p_FIX__SymbolSfx,
  &_swigt__p_FIX__SynchronizedApplication,
  &_swigt__p_FIX__TYPE__Type,
  &_swigt__p_FIX__TZTIMEONLY,
  &_swigt__p_FIX__TZTIMESTAMP,
  &_swigt__p_FIX__TZTransactTime,
  &_swigt__p_FIX__TagNotDefinedForMessage,
  &_swigt__p_FIX__TagOutOfOrder,
  &_swigt__p_FIX__TargetCompID,
  &_swigt__p_FIX__TargetLocationID,
  &_swigt__p_FIX__TargetPartyID,
  &_swigt__p_FIX__TargetPartyIDSource,
  &_swigt__p_FIX__TargetPartyRole,
  &_swigt__p_FIX__TargetStrategy,
  &_swigt__p_FIX__TargetStrategyParameters,
  &_swigt__p_FIX__TargetStrategyPerformance,
  &_swigt__p_FIX__TargetSubID,
  &_swigt__p_FIX__TaxAdvantageType,
  &_swigt__p_FIX__TerminationType,
  &_swigt__p_FIX__TestMessageIndicator,
  &_swigt__p_FIX__TestReqID,
  &_swigt__p_FIX__Text,
  &_swigt__p_FIX__ThresholdAmount,
  &_swigt__p_FIX__TickDirection,
  &_swigt__p_FIX__TickIncrement,
  &_swigt__p_FIX__TickRuleType,
  &_swigt__p_FIX__TierCode,
  &_swigt__p_FIX__TimeBracket,
  &_swigt__p_FIX__TimeInForce,
  &_swigt__p_FIX__TimeToExpiration,
  &_swigt__p_FIX__TimeUnit,
  &_swigt__p_FIX__TotNoAccQuotes,
  &_swigt__p_FIX__TotNoAllocs,
  &_swigt__p_FIX__TotNoCxldQuotes,
  &_swigt__p_FIX__TotNoFills,
  &_swigt__p_FIX__TotNoOrders,
  &_swigt__p_FIX__TotNoQuoteEntries,
  &_swigt__p_FIX__TotNoRejQuotes,
  &_swigt__p_FIX__TotNoRelatedSym,
  &_swigt__p_FIX__TotNoSecurityTypes,
  &_swigt__p_FIX__TotNoStrikes,
  &_swigt__p_FIX__TotNumAssignmentReports,
  &_swigt__p_FIX__TotNumReports,
  &_swigt__p_FIX__TotNumTradeReports,
  &_swigt__p_FIX__TotQuoteEntries,
  &_swigt__p_FIX__TotalAccruedInterestAmt,
  &_swigt__p_FIX__TotalAffectedOrders,
  &_swigt__p_FIX__TotalNetValue,
  &_swigt__p_FIX__TotalNumPosReports,
  &_swigt__p_FIX__TotalNumSecurities,
  &_swigt__p_FIX__TotalNumSecurityTypes,
  &_swigt__p_FIX__TotalTakedown,
  &_swigt__p_FIX__TotalVolumeTraded,
  &_swigt__p_FIX__TotalVolumeTradedDate,
  &_swigt__p_FIX__TotalVolumeTradedTime,
  &_swigt__p_FIX__TradSesCloseTime,
  &_swigt__p_FIX__TradSesEndTime,
  &_swigt__p_FIX__TradSesEvent,
  &_swigt__p_FIX__TradSesMethod,
  &_swigt__p_FIX__TradSesMode,
  &_swigt__p_FIX__TradSesOpenTime,
  &_swigt__p_FIX__TradSesPreCloseTime,
  &_swigt__p_FIX__TradSesReqID,
  &_swigt__p_FIX__TradSesStartTime,
  &_swigt__p_FIX__TradSesStatus,
  &_swigt__p_FIX__TradSesStatusRejReason,
  &_swigt__p_FIX__TradSesUpdateAction,
  &_swigt__p_FIX__TradeAllocIndicator,
  &_swigt__p_FIX__TradeCondition,
  &_swigt__p_FIX__TradeDate,
  &_swigt__p_FIX__TradeHandlingInstr,
  &_swigt__p_FIX__TradeID,
  &_swigt__p_FIX__TradeInputDevice,
  &_swigt__p_FIX__TradeInputSource,
  &_swigt__p_FIX__TradeLegRefID,
  &_swigt__p_FIX__TradeLinkID,
  &_swigt__p_FIX__TradeOriginationDate,
  &_swigt__p_FIX__TradePublishIndicator,
  &_swigt__p_FIX__TradeReportID,
  &_swigt__p_FIX__TradeReportRefID,
  &_swigt__p_FIX__TradeReportRejectReason,
  &_swigt__p_FIX__TradeReportTransType,
  &_swigt__p_FIX__TradeReportType,
  &_swigt__p_FIX__TradeRequestID,
  &_swigt__p_FIX__TradeRequestResult,
  &_swigt__p_FIX__TradeRequestStatus,
  &_swigt__p_FIX__TradeRequestType,
  &_swigt__p_FIX__TradeType,
  &_swigt__p_FIX__TradeVolume,
  &_swigt__p_FIX__TradedFlatSwitch,
  &_swigt__p_FIX__TradingCurrency,
  &_swigt__p_FIX__TradingReferencePrice,
  &_swigt__p_FIX__TradingSessionDesc,
  &_swigt__p_FIX__TradingSessionID,
  &_swigt__p_FIX__TradingSessionSubID,
  &_swigt__p_FIX__Trailer,
  &_swigt__p_FIX__TransBkdTime,
  &_swigt__p_FIX__TransactTime,
  &_swigt__p_FIX__TransferReason,
  &_swigt__p_FIX__TrdMatchID,
  &_swigt__p_FIX__TrdRegTimestamp,
  &_swigt__p_FIX__TrdRegTimestampOrigin,
  &_swigt__p_FIX__TrdRegTimestampType,
  &_swigt__p_FIX__TrdRepIndicator,
  &_swigt__p_FIX__TrdRepPartyRole,
  &_swigt__p_FIX__TrdRptStatus,
  &_swigt__p_FIX__TrdSubType,
  &_swigt__p_FIX__TrdType,
  &_swigt__p_FIX__TriggerAction,
  &_swigt__p_FIX__TriggerNewPrice,
  &_swigt__p_FIX__TriggerNewQty,
  &_swigt__p_FIX__TriggerOrderType,
  &_swigt__p_FIX__TriggerPrice,
  &_swigt__p_FIX__TriggerPriceDirection,
  &_swigt__p_FIX__TriggerPriceType,
  &_swigt__p_FIX__TriggerPriceTypeScope,
  &_swigt__p_FIX__TriggerSecurityDesc,
  &_swigt__p_FIX__TriggerSecurityID,
  &_swigt__p_FIX__TriggerSecurityIDSource,
  &_swigt__p_FIX__TriggerSymbol,
  &_swigt__p_FIX__TriggerTradingSessionID,
  &_swigt__p_FIX__TriggerTradingSessionSubID,
  &_swigt__p_FIX__TriggerType,
  &_swigt__p_FIX__URLLink,
  &_swigt__p_FIX__UTCDATE,
  &_swigt__p_FIX__UTCDATEONLY,
  &_swigt__p_FIX__UTCTIMEONLY,
  &_swigt__p_FIX__UTCTIMESTAMP,
  &_swigt__p_FIX__UnderlyingAdjustedQuantity,
  &_swigt__p_FIX__UnderlyingAllocationPercent,
  &_swigt__p_FIX__UnderlyingAttachmentPoint,
  &_swigt__p_FIX__UnderlyingCFICode,
  &_swigt__p_FIX__UnderlyingCPProgram,
  &_swigt__p_FIX__UnderlyingCPRegType,
  &_swigt__p_FIX__UnderlyingCapValue,
  &_swigt__p_FIX__UnderlyingCashAmount,
  &_swigt__p_FIX__UnderlyingCashType,
  &_swigt__p_FIX__UnderlyingCollectAmount,
  &_swigt__p_FIX__UnderlyingContractMultiplier,
  &_swigt__p_FIX__UnderlyingContractMultiplierUnit,
  &_swigt__p_FIX__UnderlyingCountryOfIssue,
  &_swigt__p_FIX__UnderlyingCouponPaymentDate,
  &_swigt__p_FIX__UnderlyingCouponRate,
  &_swigt__p_FIX__UnderlyingCreditRating,
  &_swigt__p_FIX__UnderlyingCurrency,
  &_swigt__p_FIX__UnderlyingCurrentValue,
  &_swigt__p_FIX__UnderlyingDeliveryAmount,
  &_swigt__p_FIX__UnderlyingDetachmentPoint,
  &_swigt__p_FIX__UnderlyingDirtyPrice,
  &_swigt__p_FIX__UnderlyingEndPrice,
  &_swigt__p_FIX__UnderlyingEndValue,
  &_swigt__p_FIX__UnderlyingExerciseStyle,
  &_swigt__p_FIX__UnderlyingFXRate,
  &_swigt__p_FIX__UnderlyingFXRateCalc,
  &_swigt__p_FIX__UnderlyingFactor,
  &_swigt__p_FIX__UnderlyingFlowScheduleType,
  &_swigt__p_FIX__UnderlyingIDSource,
  &_swigt__p_FIX__UnderlyingInstrRegistry,
  &_swigt__p_FIX__UnderlyingInstrumentPartyID,
  &_swigt__p_FIX__UnderlyingInstrumentPartyIDSource,
  &_swigt__p_FIX__UnderlyingInstrumentPartyRole,
  &_swigt__p_FIX__UnderlyingInstrumentPartySubID,
  &_swigt__p_FIX__UnderlyingInstrumentPartySubIDType,
  &_swigt__p_FIX__UnderlyingIssueDate,
  &_swigt__p_FIX__UnderlyingIssuer,
  &_swigt__p_FIX__UnderlyingLastPx,
  &_swigt__p_FIX__UnderlyingLastQty,
  &_swigt__p_FIX__UnderlyingLegCFICode,
  &_swigt__p_FIX__UnderlyingLegMaturityDate,
  &_swigt__p_FIX__UnderlyingLegMaturityMonthYear,
  &_swigt__p_FIX__UnderlyingLegMaturityTime,
  &_swigt__p_FIX__UnderlyingLegOptAttribute,
  &_swigt__p_FIX__UnderlyingLegPutOrCall,
  &_swigt__p_FIX__UnderlyingLegSecurityAltID,
  &_swigt__p_FIX__UnderlyingLegSecurityAltIDSource,
  &_swigt__p_FIX__UnderlyingLegSecurityDesc,
  &_swigt__p_FIX__UnderlyingLegSecurityExchange,
  &_swigt__p_FIX__UnderlyingLegSecurityID,
  &_swigt__p_FIX__UnderlyingLegSecurityIDSource,
  &_swigt__p_FIX__UnderlyingLegSecuritySubType,
  &_swigt__p_FIX__UnderlyingLegSecurityType,
  &_swigt__p_FIX__UnderlyingLegStrikePrice,
  &_swigt__p_FIX__UnderlyingLegSymbol,
  &_swigt__p_FIX__UnderlyingLegSymbolSfx,
  &_swigt__p_FIX__UnderlyingLocaleOfIssue,
  &_swigt__p_FIX__UnderlyingMaturityDate,
  &_swigt__p_FIX__UnderlyingMaturityDay,
  &_swigt__p_FIX__UnderlyingMaturityMonthYear,
  &_swigt__p_FIX__UnderlyingMaturityTime,
  &_swigt__p_FIX__UnderlyingNotionalPercentageOutstanding,
  &_swigt__p_FIX__UnderlyingOptAttribute,
  &_swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding,
  &_swigt__p_FIX__UnderlyingPayAmount,
  &_swigt__p_FIX__UnderlyingPriceDeterminationMethod,
  &_swigt__p_FIX__UnderlyingPriceUnitOfMeasure,
  &_swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty,
  &_swigt__p_FIX__UnderlyingProduct,
  &_swigt__p_FIX__UnderlyingPutOrCall,
  &_swigt__p_FIX__UnderlyingPx,
  &_swigt__p_FIX__UnderlyingQty,
  &_swigt__p_FIX__UnderlyingRedemptionDate,
  &_swigt__p_FIX__UnderlyingRepoCollateralSecurityType,
  &_swigt__p_FIX__UnderlyingRepurchaseRate,
  &_swigt__p_FIX__UnderlyingRepurchaseTerm,
  &_swigt__p_FIX__UnderlyingRestructuringType,
  &_swigt__p_FIX__UnderlyingSecurityAltID,
  &_swigt__p_FIX__UnderlyingSecurityAltIDSource,
  &_swigt__p_FIX__UnderlyingSecurityDesc,
  &_swigt__p_FIX__UnderlyingSecurityExchange,
  &_swigt__p_FIX__UnderlyingSecurityID,
  &_swigt__p_FIX__UnderlyingSecurityIDSource,
  &_swigt__p_FIX__UnderlyingSecuritySubType,
  &_swigt__p_FIX__UnderlyingSecurityType,
  &_swigt__p_FIX__UnderlyingSeniority,
  &_swigt__p_FIX__UnderlyingSettlMethod,
  &_swigt__p_FIX__UnderlyingSettlPrice,
  &_swigt__p_FIX__UnderlyingSettlPriceType,
  &_swigt__p_FIX__UnderlyingSettlementDate,
  &_swigt__p_FIX__UnderlyingSettlementStatus,
  &_swigt__p_FIX__UnderlyingSettlementType,
  &_swigt__p_FIX__UnderlyingStartValue,
  &_swigt__p_FIX__UnderlyingStateOrProvinceOfIssue,
  &_swigt__p_FIX__UnderlyingStipType,
  &_swigt__p_FIX__UnderlyingStipValue,
  &_swigt__p_FIX__UnderlyingStrikeCurrency,
  &_swigt__p_FIX__UnderlyingStrikePrice,
  &_swigt__p_FIX__UnderlyingSymbol,
  &_swigt__p_FIX__UnderlyingSymbolSfx,
  &_swigt__p_FIX__UnderlyingTimeUnit,
  &_swigt__p_FIX__UnderlyingTradingSessionID,
  &_swigt__p_FIX__UnderlyingTradingSessionSubID,
  &_swigt__p_FIX__UnderlyingUnitOfMeasure,
  &_swigt__p_FIX__UnderlyingUnitOfMeasureQty,
  &_swigt__p_FIX__UndlyInstrumentPartyID,
  &_swigt__p_FIX__UndlyInstrumentPartyIDSource,
  &_swigt__p_FIX__UndlyInstrumentPartyRole,
  &_swigt__p_FIX__UndlyInstrumentPartySubID,
  &_swigt__p_FIX__UndlyInstrumentPartySubIDType,
  &_swigt__p_FIX__UnitOfMeasure,
  &_swigt__p_FIX__UnitOfMeasureQty,
  &_swigt__p_FIX__UnsolicitedIndicator,
  &_swigt__p_FIX__UnsupportedMessageType,
  &_swigt__p_FIX__UnsupportedVersion,
  &_swigt__p_FIX__Urgency,
  &_swigt__p_FIX__UserRequestID,
  &_swigt__p_FIX__UserRequestType,
  &_swigt__p_FIX__UserStatus,
  &_swigt__p_FIX__UserStatusText,
  &_swigt__p_FIX__Username,
  &_swigt__p_FIX__UtcDateField,
  &_swigt__p_FIX__UtcTimeOnlyField,
  &_swigt__p_FIX__UtcTimeStampField,
  &_swigt__p_FIX__ValidUntilTime,
  &_swigt__p_FIX__ValuationMethod,
  &_swigt__p_FIX__ValueOfFutures,
  &_swigt__p_FIX__VenueType,
  &_swigt__p_FIX__Volatility,
  &_swigt__p_FIX__WaveNo,
  &_swigt__p_FIX__WorkingIndicator,
  &_swigt__p_FIX__WtAverageLiquidity,
  &_swigt__p_FIX__XMLDATA,
  &_swigt__p_FIX__XmlData,
  &_swigt__p_FIX__XmlDataLen,
  &_swigt__p_FIX__Yield,
  &_swigt__p_FIX__YieldCalcDate,
  &_swigt__p_FIX__YieldRedemptionDate,
  &_swigt__p_FIX__YieldRedemptionPrice,
  &_swigt__p_FIX__YieldRedemptionPriceType,
  &_swigt__p_FIX__YieldType,
  &_swigt__p_Fields,
  &_swigt__p_Group,
  &_swigt__p_Groups,
  &_swigt__p_IntArray,
  &_swigt__p_IntField,
  &_swigt__p_Log,
  &_swigt__p_LogFactory,
  &_swigt__p_MessageStore,
  &_swigt__p_MessageStoreFactory,
  &_swigt__p_MsgType,
  &_swigt__p_Mutex,
  &_swigt__p_Responder,
  &_swigt__p_SessionID,
  &_swigt__p_StringField,
  &_swigt__p_TimeRange,
  &_swigt__p_UtcDate,
  &_swigt__p_UtcDateField,
  &_swigt__p_UtcTimeOnly,
  &_swigt__p_UtcTimeStamp,
  &_swigt__p_bool,
  &_swigt__p_char,
  &_swigt__p_const_iterator,
  &_swigt__p_g_const_iterator,
  &_swigt__p_g_iterator,
  &_swigt__p_int,
  &_swigt__p_iterator,
  &_swigt__p_message_order,
  &_swigt__p_p_FIX__DataDictionary,
  &_swigt__p_std__istream,
  &_swigt__p_std__ostream,
  &_swigt__p_std__setT_FIX__SessionID_t,
  &_swigt__p_std__string,
  &_swigt__p_std__string__size_type,
  &_swigt__p_std__vectorT_std__string_t,
};

static swig_cast_info _swigc__p_ApplVerID[] = {  {&_swigt__p_ApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Application[] = {  {&_swigt__p_Application, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BeginString[] = {  {&_swigt__p_BeginString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DOMDocumentPtr[] = {  {&_swigt__p_DOMDocumentPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Data[] = {  {&_swigt__p_Data, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DataDictionary[] = {  {&_swigt__p_DataDictionary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DataDictionaryProvider[] = {  {&_swigt__p_DataDictionaryProvider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Dictionaries[] = {  {&_swigt__p_Dictionaries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DoubleField[] = {  {&_swigt__p_DoubleField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AMT[] = {  {&_swigt__p_FIX__AMT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Acceptor[] = {  {&_swigt__p_FIX__Acceptor, 0, 0, 0},  {&_swigt__p_FIX__SocketAcceptor, _p_FIX__SocketAcceptorTo_p_FIX__Acceptor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Account[] = {  {&_swigt__p_FIX__Account, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AccountType[] = {  {&_swigt__p_FIX__AccountType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AccruedInterestAmt[] = {  {&_swigt__p_FIX__AccruedInterestAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AccruedInterestRate[] = {  {&_swigt__p_FIX__AccruedInterestRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AcctIDSource[] = {  {&_swigt__p_FIX__AcctIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Adjustment[] = {  {&_swigt__p_FIX__Adjustment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdjustmentType[] = {  {&_swigt__p_FIX__AdjustmentType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdvId[] = {  {&_swigt__p_FIX__AdvId, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdvRefID[] = {  {&_swigt__p_FIX__AdvRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdvSide[] = {  {&_swigt__p_FIX__AdvSide, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AdvTransType[] = {  {&_swigt__p_FIX__AdvTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AffectedOrderID[] = {  {&_swigt__p_FIX__AffectedOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AffectedSecondaryOrderID[] = {  {&_swigt__p_FIX__AffectedSecondaryOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AffirmStatus[] = {  {&_swigt__p_FIX__AffirmStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AggregatedBook[] = {  {&_swigt__p_FIX__AggregatedBook, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AggressorIndicator[] = {  {&_swigt__p_FIX__AggressorIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AgreementCurrency[] = {  {&_swigt__p_FIX__AgreementCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AgreementDate[] = {  {&_swigt__p_FIX__AgreementDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AgreementDesc[] = {  {&_swigt__p_FIX__AgreementDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AgreementID[] = {  {&_swigt__p_FIX__AgreementID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAccount[] = {  {&_swigt__p_FIX__AllocAccount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAccountType[] = {  {&_swigt__p_FIX__AllocAccountType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAccruedInterestAmt[] = {  {&_swigt__p_FIX__AllocAccruedInterestAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAcctIDSource[] = {  {&_swigt__p_FIX__AllocAcctIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocAvgPx[] = {  {&_swigt__p_FIX__AllocAvgPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocCancReplaceReason[] = {  {&_swigt__p_FIX__AllocCancReplaceReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocClearingFeeIndicator[] = {  {&_swigt__p_FIX__AllocClearingFeeIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocCustomerCapacity[] = {  {&_swigt__p_FIX__AllocCustomerCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocHandlInst[] = {  {&_swigt__p_FIX__AllocHandlInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocID[] = {  {&_swigt__p_FIX__AllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocInterestAtMaturity[] = {  {&_swigt__p_FIX__AllocInterestAtMaturity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocIntermedReqType[] = {  {&_swigt__p_FIX__AllocIntermedReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocLinkID[] = {  {&_swigt__p_FIX__AllocLinkID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocLinkType[] = {  {&_swigt__p_FIX__AllocLinkType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocMethod[] = {  {&_swigt__p_FIX__AllocMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocNetMoney[] = {  {&_swigt__p_FIX__AllocNetMoney, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocNoOrdersType[] = {  {&_swigt__p_FIX__AllocNoOrdersType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocPositionEffect[] = {  {&_swigt__p_FIX__AllocPositionEffect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocPrice[] = {  {&_swigt__p_FIX__AllocPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocQty[] = {  {&_swigt__p_FIX__AllocQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocRejCode[] = {  {&_swigt__p_FIX__AllocRejCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocReportID[] = {  {&_swigt__p_FIX__AllocReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocReportRefID[] = {  {&_swigt__p_FIX__AllocReportRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocReportType[] = {  {&_swigt__p_FIX__AllocReportType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocSettlCurrAmt[] = {  {&_swigt__p_FIX__AllocSettlCurrAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocSettlCurrency[] = {  {&_swigt__p_FIX__AllocSettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocSettlInstType[] = {  {&_swigt__p_FIX__AllocSettlInstType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocShares[] = {  {&_swigt__p_FIX__AllocShares, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocStatus[] = {  {&_swigt__p_FIX__AllocStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocText[] = {  {&_swigt__p_FIX__AllocText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocTransType[] = {  {&_swigt__p_FIX__AllocTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllocType[] = {  {&_swigt__p_FIX__AllocType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllowableOneSidednessCurr[] = {  {&_swigt__p_FIX__AllowableOneSidednessCurr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllowableOneSidednessPct[] = {  {&_swigt__p_FIX__AllowableOneSidednessPct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AllowableOneSidednessValue[] = {  {&_swigt__p_FIX__AllowableOneSidednessValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AltMDSourceID[] = {  {&_swigt__p_FIX__AltMDSourceID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplBegSeqNum[] = {  {&_swigt__p_FIX__ApplBegSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplEndSeqNum[] = {  {&_swigt__p_FIX__ApplEndSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplExtID[] = {  {&_swigt__p_FIX__ApplExtID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplID[] = {  {&_swigt__p_FIX__ApplID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplLastSeqNum[] = {  {&_swigt__p_FIX__ApplLastSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplNewSeqNum[] = {  {&_swigt__p_FIX__ApplNewSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplQueueAction[] = {  {&_swigt__p_FIX__ApplQueueAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplQueueDepth[] = {  {&_swigt__p_FIX__ApplQueueDepth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplQueueMax[] = {  {&_swigt__p_FIX__ApplQueueMax, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplQueueResolution[] = {  {&_swigt__p_FIX__ApplQueueResolution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplReportID[] = {  {&_swigt__p_FIX__ApplReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplReportType[] = {  {&_swigt__p_FIX__ApplReportType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplReqID[] = {  {&_swigt__p_FIX__ApplReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplReqType[] = {  {&_swigt__p_FIX__ApplReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplResendFlag[] = {  {&_swigt__p_FIX__ApplResendFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplResponseError[] = {  {&_swigt__p_FIX__ApplResponseError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplResponseID[] = {  {&_swigt__p_FIX__ApplResponseID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplResponseType[] = {  {&_swigt__p_FIX__ApplResponseType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplSeqNum[] = {  {&_swigt__p_FIX__ApplSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplTotalMessageCount[] = {  {&_swigt__p_FIX__ApplTotalMessageCount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ApplVerID[] = {  {&_swigt__p_FIX__ApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Application[] = {  {&_swigt__p_FIX__Application, 0, 0, 0},  {&_swigt__p_FIX__SynchronizedApplication, _p_FIX__SynchronizedApplicationTo_p_FIX__Application, 0, 0},  {&_swigt__p_FIX__NullApplication, _p_FIX__NullApplicationTo_p_FIX__Application, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AsOfIndicator[] = {  {&_swigt__p_FIX__AsOfIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AsgnRptID[] = {  {&_swigt__p_FIX__AsgnRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AssignmentMethod[] = {  {&_swigt__p_FIX__AssignmentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AssignmentUnit[] = {  {&_swigt__p_FIX__AssignmentUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AttachmentPoint[] = {  {&_swigt__p_FIX__AttachmentPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AutoAcceptIndicator[] = {  {&_swigt__p_FIX__AutoAcceptIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgParPx[] = {  {&_swigt__p_FIX__AvgParPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgPrxPrecision[] = {  {&_swigt__p_FIX__AvgPrxPrecision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgPx[] = {  {&_swigt__p_FIX__AvgPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgPxIndicator[] = {  {&_swigt__p_FIX__AvgPxIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__AvgPxPrecision[] = {  {&_swigt__p_FIX__AvgPxPrecision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BOOLEAN[] = {  {&_swigt__p_FIX__BOOLEAN, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BasisFeatureDate[] = {  {&_swigt__p_FIX__BasisFeatureDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BasisFeaturePrice[] = {  {&_swigt__p_FIX__BasisFeaturePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BasisPxType[] = {  {&_swigt__p_FIX__BasisPxType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BeginSeqNo[] = {  {&_swigt__p_FIX__BeginSeqNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BeginString[] = {  {&_swigt__p_FIX__BeginString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Benchmark[] = {  {&_swigt__p_FIX__Benchmark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkCurveCurrency[] = {  {&_swigt__p_FIX__BenchmarkCurveCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkCurveName[] = {  {&_swigt__p_FIX__BenchmarkCurveName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkCurvePoint[] = {  {&_swigt__p_FIX__BenchmarkCurvePoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkPrice[] = {  {&_swigt__p_FIX__BenchmarkPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkPriceType[] = {  {&_swigt__p_FIX__BenchmarkPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkSecurityID[] = {  {&_swigt__p_FIX__BenchmarkSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BenchmarkSecurityIDSource[] = {  {&_swigt__p_FIX__BenchmarkSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidDescriptor[] = {  {&_swigt__p_FIX__BidDescriptor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidDescriptorType[] = {  {&_swigt__p_FIX__BidDescriptorType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidForwardPoints[] = {  {&_swigt__p_FIX__BidForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidForwardPoints2[] = {  {&_swigt__p_FIX__BidForwardPoints2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidID[] = {  {&_swigt__p_FIX__BidID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidPx[] = {  {&_swigt__p_FIX__BidPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidRequestTransType[] = {  {&_swigt__p_FIX__BidRequestTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidSize[] = {  {&_swigt__p_FIX__BidSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidSpotRate[] = {  {&_swigt__p_FIX__BidSpotRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidSwapPoints[] = {  {&_swigt__p_FIX__BidSwapPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidTradeType[] = {  {&_swigt__p_FIX__BidTradeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidType[] = {  {&_swigt__p_FIX__BidType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BidYield[] = {  {&_swigt__p_FIX__BidYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BodyLength[] = {  {&_swigt__p_FIX__BodyLength, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BookingRefID[] = {  {&_swigt__p_FIX__BookingRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BookingType[] = {  {&_swigt__p_FIX__BookingType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BookingUnit[] = {  {&_swigt__p_FIX__BookingUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BoolField[] = {  {&_swigt__p_FIX__InViewOfCommon, _p_FIX__InViewOfCommonTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PrivateQuote, _p_FIX__PrivateQuoteTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ResetSeqNumFlag, _p_FIX__ResetSeqNumFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__DueToRelated, _p_FIX__DueToRelatedTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__AggregatedBook, _p_FIX__AggregatedBookTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__LegalConfirm, _p_FIX__LegalConfirmTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ForexReq, _p_FIX__ForexReqTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__FlexibleIndicator, _p_FIX__FlexibleIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__LateIndicator, _p_FIX__LateIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PublishTrdIndicator, _p_FIX__PublishTrdIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__TrdRepIndicator, _p_FIX__TrdRepIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__DefaultVerIndicator, _p_FIX__DefaultVerIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__RefreshIndicator, _p_FIX__RefreshIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__AutoAcceptIndicator, _p_FIX__AutoAcceptIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__UnsolicitedIndicator, _p_FIX__UnsolicitedIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__CopyMsgIndicator, _p_FIX__CopyMsgIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__DerivFlexProductEligibilityIndicator, _p_FIX__DerivFlexProductEligibilityIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__TestMessageIndicator, _p_FIX__TestMessageIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__WorkingIndicator, _p_FIX__WorkingIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__AggressorIndicator, _p_FIX__AggressorIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__FlexProductEligibilityIndicator, _p_FIX__FlexProductEligibilityIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ReversalIndicator, _p_FIX__ReversalIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ContraryInstructionIndicator, _p_FIX__ContraryInstructionIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ManualOrderIndicator, _p_FIX__ManualOrderIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PriorSpreadIndicator, _p_FIX__PriorSpreadIndicatorTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ReportToExch, _p_FIX__ReportToExchTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__OddLot, _p_FIX__OddLotTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__IOINaturalFlag, _p_FIX__IOINaturalFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ExchangeForPhysical, _p_FIX__ExchangeForPhysicalTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__LastRptRequested, _p_FIX__LastRptRequestedTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__SolicitedFlag, _p_FIX__SolicitedFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__TradedFlatSwitch, _p_FIX__TradedFlatSwitchTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__CustDirectedOrder, _p_FIX__CustDirectedOrderTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__BoolField, 0, 0, 0},  {&_swigt__p_FIX__LocateReqd, _p_FIX__LocateReqdTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__NotifyBrokerOfCredit, _p_FIX__NotifyBrokerOfCreditTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__MDImplicitDelete, _p_FIX__MDImplicitDeleteTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PossResend, _p_FIX__PossResendTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PossDupFlag, _p_FIX__PossDupFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PreTradeAnonymity, _p_FIX__PreTradeAnonymityTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ReportedPxDiff, _p_FIX__ReportedPxDiffTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__ApplResendFlag, _p_FIX__ApplResendFlagTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__PreviouslyReported, _p_FIX__PreviouslyReportedTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__LastFragment, _p_FIX__LastFragmentTo_p_FIX__BoolField, 0, 0},  {&_swigt__p_FIX__GapFillFlag, _p_FIX__GapFillFlagTo_p_FIX__BoolField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BrokerOfCredit[] = {  {&_swigt__p_FIX__BrokerOfCredit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BusinessRejectReason[] = {  {&_swigt__p_FIX__BusinessRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BusinessRejectRefID[] = {  {&_swigt__p_FIX__BusinessRejectRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__BuyVolume[] = {  {&_swigt__p_FIX__BuyVolume, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CFICode[] = {  {&_swigt__p_FIX__CFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CHAR[] = {  {&_swigt__p_FIX__CHAR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__COUNTRY[] = {  {&_swigt__p_FIX__COUNTRY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CPProgram[] = {  {&_swigt__p_FIX__CPProgram, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CPRegType[] = {  {&_swigt__p_FIX__CPRegType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CURRENCY[] = {  {&_swigt__p_FIX__CURRENCY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CalculatedCcyLastQty[] = {  {&_swigt__p_FIX__CalculatedCcyLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CancellationRights[] = {  {&_swigt__p_FIX__CancellationRights, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CapPrice[] = {  {&_swigt__p_FIX__CapPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardExpDate[] = {  {&_swigt__p_FIX__CardExpDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardHolderName[] = {  {&_swigt__p_FIX__CardHolderName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardIssNo[] = {  {&_swigt__p_FIX__CardIssNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardIssNum[] = {  {&_swigt__p_FIX__CardIssNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardNumber[] = {  {&_swigt__p_FIX__CardNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CardStartDate[] = {  {&_swigt__p_FIX__CardStartDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribAgentAcctName[] = {  {&_swigt__p_FIX__CashDistribAgentAcctName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribAgentAcctNumber[] = {  {&_swigt__p_FIX__CashDistribAgentAcctNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribAgentCode[] = {  {&_swigt__p_FIX__CashDistribAgentCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribAgentName[] = {  {&_swigt__p_FIX__CashDistribAgentName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribCurr[] = {  {&_swigt__p_FIX__CashDistribCurr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashDistribPayRef[] = {  {&_swigt__p_FIX__CashDistribPayRef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashMargin[] = {  {&_swigt__p_FIX__CashMargin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashOrderQty[] = {  {&_swigt__p_FIX__CashOrderQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashOutstanding[] = {  {&_swigt__p_FIX__CashOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentAcctName[] = {  {&_swigt__p_FIX__CashSettlAgentAcctName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentAcctNum[] = {  {&_swigt__p_FIX__CashSettlAgentAcctNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentCode[] = {  {&_swigt__p_FIX__CashSettlAgentCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentContactName[] = {  {&_swigt__p_FIX__CashSettlAgentContactName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentContactPhone[] = {  {&_swigt__p_FIX__CashSettlAgentContactPhone, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CashSettlAgentName[] = {  {&_swigt__p_FIX__CashSettlAgentName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CcyAmt[] = {  {&_swigt__p_FIX__CcyAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CharField[] = {  {&_swigt__p_FIX__MDEntryType, _p_FIX__MDEntryTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RegistStatus, _p_FIX__RegistStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrdStatus, _p_FIX__OrdStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MatchStatus, _p_FIX__MatchStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__BidTradeType, _p_FIX__BidTradeTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TradeType, _p_FIX__TradeTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__FundRenewWaiv, _p_FIX__FundRenewWaivTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OpenClose, _p_FIX__OpenCloseTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Urgency, _p_FIX__UrgencyTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__IOIOthSvc, _p_FIX__IOIOthSvcTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__EmailType, _p_FIX__EmailTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__IOITransType, _p_FIX__IOITransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AllocTransType, _p_FIX__AllocTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecTransType, _p_FIX__ExecTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__BidRequestTransType, _p_FIX__BidRequestTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RegistTransType, _p_FIX__RegistTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlInstTransType, _p_FIX__SettlInstTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlObligTransType, _p_FIX__SettlObligTransTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ListExecInstType, _p_FIX__ListExecInstTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DlvyInstType, _p_FIX__DlvyInstTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__QuoteQualifier, _p_FIX__QuoteQualifierTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__IOIQualifier, _p_FIX__IOIQualifierTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecType, _p_FIX__ExecTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlInstMode, _p_FIX__SettlInstModeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DerivativeExerciseStyle, _p_FIX__DerivativeExerciseStyleTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CharField, 0, 0, 0},  {&_swigt__p_FIX__TimeInForce, _p_FIX__TimeInForceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerType, _p_FIX__TriggerTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OwnershipType, _p_FIX__OwnershipTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AssignmentMethod, _p_FIX__AssignmentMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlMethod, _p_FIX__SettlMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrmtAssignmentMethod, _p_FIX__DerivativeInstrmtAssignmentMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__InstrmtAssignmentMethod, _p_FIX__InstrmtAssignmentMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DerivativeSettlMethod, _p_FIX__DerivativeSettlMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MDReqRejReason, _p_FIX__MDReqRejReasonTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__BookingUnit, _p_FIX__BookingUnitTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlCurrFxRateCalc, _p_FIX__SettlCurrFxRateCalcTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UnderlyingFXRateCalc, _p_FIX__UnderlyingFXRateCalcTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerAction, _p_FIX__TriggerActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DiscretionInst, _p_FIX__DiscretionInstTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecInstValue, _p_FIX__ExecInstValueTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerPriceType, _p_FIX__TriggerPriceTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecPriceType, _p_FIX__ExecPriceTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlObligSource, _p_FIX__SettlObligSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MassCancelRequestType, _p_FIX__MassCancelRequestTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SubscriptionRequestType, _p_FIX__SubscriptionRequestTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerPriceTypeScope, _p_FIX__TriggerPriceTypeScopeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ProcessCode, _p_FIX__ProcessCodeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LotType, _p_FIX__LotTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegSide, _p_FIX__LegSideTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RoundingDirection, _p_FIX__RoundingDirectionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerPriceDirection, _p_FIX__TriggerPriceDirectionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TickDirection, _p_FIX__TickDirectionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MsgDirection, _p_FIX__MsgDirectionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__HaltReasonChar, _p_FIX__HaltReasonCharTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrderCapacity, _p_FIX__OrderCapacityTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DealingCapacity, _p_FIX__DealingCapacityTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LastCapacity, _p_FIX__LastCapacityTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__PriceProtectionScope, _p_FIX__PriceProtectionScopeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__BasisPxType, _p_FIX__BasisPxTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__PositionEffect, _p_FIX__PositionEffectTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegPositionEffect, _p_FIX__LegPositionEffectTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AllocPositionEffect, _p_FIX__AllocPositionEffectTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__VenueType, _p_FIX__VenueTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__HandlInst, _p_FIX__HandlInstTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MoneyLaunderingStatus, _p_FIX__MoneyLaunderingStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExecAckStatus, _p_FIX__ExecAckStatusTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CxlRejResponseTo, _p_FIX__CxlRejResponseToTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DisplayWhen, _p_FIX__DisplayWhenTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrderCategory, _p_FIX__OrderCategoryTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MultiLegReportingType, _p_FIX__MultiLegReportingTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CxlType, _p_FIX__CxlTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Side, _p_FIX__SideTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyIDSource, _p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyIDSource, _p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Nested4PartyIDSource, _p_FIX__Nested4PartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RootPartyIDSource, _p_FIX__RootPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExDestinationIDSource, _p_FIX__ExDestinationIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Nested3PartyIDSource, _p_FIX__Nested3PartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TargetPartyIDSource, _p_FIX__TargetPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__InstrumentPartyIDSource, _p_FIX__InstrumentPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlInstSource, _p_FIX__SettlInstSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__NestedPartyIDSource, _p_FIX__NestedPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CommType, _p_FIX__CommTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__PartyIDSource, _p_FIX__PartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlPartyIDSource, _p_FIX__SettlPartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__RefOrderIDSource, _p_FIX__RefOrderIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Nested2PartyIDSource, _p_FIX__Nested2PartyIDSourceTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MassCancelResponse, _p_FIX__MassCancelResponseTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Benchmark, _p_FIX__BenchmarkTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TriggerOrderType, _p_FIX__TriggerOrderTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegSettlType, _p_FIX__LegSettlTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegSettlmntTyp, _p_FIX__LegSettlmntTypTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SettlmntTyp, _p_FIX__SettlmntTypTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__PreallocMethod, _p_FIX__PreallocMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ExerciseMethod, _p_FIX__ExerciseMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AsOfIndicator, _p_FIX__AsOfIndicatorTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DisplayMethod, _p_FIX__DisplayMethodTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrigTradeHandlingInstr, _p_FIX__OrigTradeHandlingInstrTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TradeHandlingInstr, _p_FIX__TradeHandlingInstrTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DeleteReason, _p_FIX__DeleteReasonTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DKReason, _p_FIX__DKReasonTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CancellationRights, _p_FIX__CancellationRightsTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__CashMargin, _p_FIX__CashMarginTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__Rule80A, _p_FIX__Rule80ATo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DayBookingInst, _p_FIX__DayBookingInstTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__AdvSide, _p_FIX__AdvSideTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__DerivativeOptAttribute, _p_FIX__DerivativeOptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegOptAttribute, _p_FIX__UnderlyingLegOptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OptAttribute, _p_FIX__OptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__UnderlyingOptAttribute, _p_FIX__UnderlyingOptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__IOIQltyInd, _p_FIX__IOIQltyIndTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__LegOptAttribute, _p_FIX__LegOptAttributeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__TradSesUpdateAction, _p_FIX__TradSesUpdateActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__SecurityUpdateAction, _p_FIX__SecurityUpdateActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__ListUpdateAction, _p_FIX__ListUpdateActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__OrdType, _p_FIX__OrdTypeTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MarketUpdateAction, _p_FIX__MarketUpdateActionTo_p_FIX__CharField, 0, 0},  {&_swigt__p_FIX__MDUpdateAction, _p_FIX__MDUpdateActionTo_p_FIX__CharField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CheckSum[] = {  {&_swigt__p_FIX__CheckSum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CheckSumField[] = {  {&_swigt__p_FIX__CheckSumField, 0, 0, 0},  {&_swigt__p_FIX__CheckSum, _p_FIX__CheckSumTo_p_FIX__CheckSumField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClOrdID[] = {  {&_swigt__p_FIX__ClOrdID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClOrdLinkID[] = {  {&_swigt__p_FIX__ClOrdLinkID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingAccount[] = {  {&_swigt__p_FIX__ClearingAccount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingBusinessDate[] = {  {&_swigt__p_FIX__ClearingBusinessDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingFeeIndicator[] = {  {&_swigt__p_FIX__ClearingFeeIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingFirm[] = {  {&_swigt__p_FIX__ClearingFirm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClearingInstruction[] = {  {&_swigt__p_FIX__ClearingInstruction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClientBidID[] = {  {&_swigt__p_FIX__ClientBidID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ClientID[] = {  {&_swigt__p_FIX__ClientID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAction[] = {  {&_swigt__p_FIX__CollAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollApplType[] = {  {&_swigt__p_FIX__CollApplType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnID[] = {  {&_swigt__p_FIX__CollAsgnID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnReason[] = {  {&_swigt__p_FIX__CollAsgnReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnRefID[] = {  {&_swigt__p_FIX__CollAsgnRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnRejectReason[] = {  {&_swigt__p_FIX__CollAsgnRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnRespType[] = {  {&_swigt__p_FIX__CollAsgnRespType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollAsgnTransType[] = {  {&_swigt__p_FIX__CollAsgnTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollInquiryID[] = {  {&_swigt__p_FIX__CollInquiryID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollInquiryQualifier[] = {  {&_swigt__p_FIX__CollInquiryQualifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollInquiryResult[] = {  {&_swigt__p_FIX__CollInquiryResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollInquiryStatus[] = {  {&_swigt__p_FIX__CollInquiryStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollReqID[] = {  {&_swigt__p_FIX__CollReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollRespID[] = {  {&_swigt__p_FIX__CollRespID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollRptID[] = {  {&_swigt__p_FIX__CollRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CollStatus[] = {  {&_swigt__p_FIX__CollStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CommCurrency[] = {  {&_swigt__p_FIX__CommCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CommType[] = {  {&_swigt__p_FIX__CommType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Commission[] = {  {&_swigt__p_FIX__Commission, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventCondition[] = {  {&_swigt__p_FIX__ComplexEventCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventEndDate[] = {  {&_swigt__p_FIX__ComplexEventEndDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventEndTime[] = {  {&_swigt__p_FIX__ComplexEventEndTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventPrice[] = {  {&_swigt__p_FIX__ComplexEventPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventPriceBoundaryMethod[] = {  {&_swigt__p_FIX__ComplexEventPriceBoundaryMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventPriceBoundaryPrecision[] = {  {&_swigt__p_FIX__ComplexEventPriceBoundaryPrecision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventPriceTimeType[] = {  {&_swigt__p_FIX__ComplexEventPriceTimeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventStartDate[] = {  {&_swigt__p_FIX__ComplexEventStartDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventStartTime[] = {  {&_swigt__p_FIX__ComplexEventStartTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexEventType[] = {  {&_swigt__p_FIX__ComplexEventType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplexOptPayoutAmount[] = {  {&_swigt__p_FIX__ComplexOptPayoutAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ComplianceID[] = {  {&_swigt__p_FIX__ComplianceID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Concession[] = {  {&_swigt__p_FIX__Concession, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfigError[] = {  {&_swigt__p_FIX__ConfigError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmID[] = {  {&_swigt__p_FIX__ConfirmID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmRefID[] = {  {&_swigt__p_FIX__ConfirmRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmRejReason[] = {  {&_swigt__p_FIX__ConfirmRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmReqID[] = {  {&_swigt__p_FIX__ConfirmReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmStatus[] = {  {&_swigt__p_FIX__ConfirmStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmTransType[] = {  {&_swigt__p_FIX__ConfirmTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ConfirmType[] = {  {&_swigt__p_FIX__ConfirmType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContAmtCurr[] = {  {&_swigt__p_FIX__ContAmtCurr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContAmtType[] = {  {&_swigt__p_FIX__ContAmtType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContAmtValue[] = {  {&_swigt__p_FIX__ContAmtValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContIntRptID[] = {  {&_swigt__p_FIX__ContIntRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContingencyType[] = {  {&_swigt__p_FIX__ContingencyType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraBroker[] = {  {&_swigt__p_FIX__ContraBroker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraLegRefID[] = {  {&_swigt__p_FIX__ContraLegRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraTradeQty[] = {  {&_swigt__p_FIX__ContraTradeQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraTradeTime[] = {  {&_swigt__p_FIX__ContraTradeTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraTrader[] = {  {&_swigt__p_FIX__ContraTrader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContractMultiplier[] = {  {&_swigt__p_FIX__ContractMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContractMultiplierUnit[] = {  {&_swigt__p_FIX__ContractMultiplierUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContractSettlMonth[] = {  {&_swigt__p_FIX__ContractSettlMonth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ContraryInstructionIndicator[] = {  {&_swigt__p_FIX__ContraryInstructionIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CopyMsgIndicator[] = {  {&_swigt__p_FIX__CopyMsgIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CorporateAction[] = {  {&_swigt__p_FIX__CorporateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Country[] = {  {&_swigt__p_FIX__Country, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CountryOfIssue[] = {  {&_swigt__p_FIX__CountryOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CouponPaymentDate[] = {  {&_swigt__p_FIX__CouponPaymentDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CouponRate[] = {  {&_swigt__p_FIX__CouponRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CoveredOrUncovered[] = {  {&_swigt__p_FIX__CoveredOrUncovered, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CreditRating[] = {  {&_swigt__p_FIX__CreditRating, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CrossID[] = {  {&_swigt__p_FIX__CrossID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CrossPercent[] = {  {&_swigt__p_FIX__CrossPercent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CrossPrioritization[] = {  {&_swigt__p_FIX__CrossPrioritization, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CrossType[] = {  {&_swigt__p_FIX__CrossType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CstmApplVerID[] = {  {&_swigt__p_FIX__CstmApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CumQty[] = {  {&_swigt__p_FIX__CumQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Currency[] = {  {&_swigt__p_FIX__Currency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CurrencyRatio[] = {  {&_swigt__p_FIX__CurrencyRatio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CustDirectedOrder[] = {  {&_swigt__p_FIX__CustDirectedOrder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CustOrderCapacity[] = {  {&_swigt__p_FIX__CustOrderCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CustOrderHandlingInst[] = {  {&_swigt__p_FIX__CustOrderHandlingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CustomerOrFirm[] = {  {&_swigt__p_FIX__CustomerOrFirm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CxlQty[] = {  {&_swigt__p_FIX__CxlQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CxlRejReason[] = {  {&_swigt__p_FIX__CxlRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CxlRejResponseTo[] = {  {&_swigt__p_FIX__CxlRejResponseTo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__CxlType[] = {  {&_swigt__p_FIX__CxlType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DATA[] = {  {&_swigt__p_FIX__DATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DAYOFMONTH[] = {  {&_swigt__p_FIX__DAYOFMONTH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DKReason[] = {  {&_swigt__p_FIX__DKReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DataDictionary[] = {  {&_swigt__p_FIX__DataDictionary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DataDictionaryNotFound[] = {  {&_swigt__p_FIX__DataDictionaryNotFound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DateOfBirth[] = {  {&_swigt__p_FIX__DateOfBirth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DatedDate[] = {  {&_swigt__p_FIX__DatedDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DayAvgPx[] = {  {&_swigt__p_FIX__DayAvgPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DayBookingInst[] = {  {&_swigt__p_FIX__DayBookingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DayCumQty[] = {  {&_swigt__p_FIX__DayCumQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DayOrderQty[] = {  {&_swigt__p_FIX__DayOrderQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DealingCapacity[] = {  {&_swigt__p_FIX__DealingCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefBidSize[] = {  {&_swigt__p_FIX__DefBidSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefOfferSize[] = {  {&_swigt__p_FIX__DefOfferSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefaultApplExtID[] = {  {&_swigt__p_FIX__DefaultApplExtID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefaultApplVerID[] = {  {&_swigt__p_FIX__DefaultApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefaultCstmApplVerID[] = {  {&_swigt__p_FIX__DefaultCstmApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DefaultVerIndicator[] = {  {&_swigt__p_FIX__DefaultVerIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeleteReason[] = {  {&_swigt__p_FIX__DeleteReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliverToCompID[] = {  {&_swigt__p_FIX__DeliverToCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliverToLocationID[] = {  {&_swigt__p_FIX__DeliverToLocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliverToSubID[] = {  {&_swigt__p_FIX__DeliverToSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliveryDate[] = {  {&_swigt__p_FIX__DeliveryDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliveryForm[] = {  {&_swigt__p_FIX__DeliveryForm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeliveryType[] = {  {&_swigt__p_FIX__DeliveryType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivFlexProductEligibilityIndicator[] = {  {&_swigt__p_FIX__DerivFlexProductEligibilityIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeCFICode[] = {  {&_swigt__p_FIX__DerivativeCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeCapPrice[] = {  {&_swigt__p_FIX__DerivativeCapPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeContractMultiplier[] = {  {&_swigt__p_FIX__DerivativeContractMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeContractMultiplierUnit[] = {  {&_swigt__p_FIX__DerivativeContractMultiplierUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeContractSettlMonth[] = {  {&_swigt__p_FIX__DerivativeContractSettlMonth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeCountryOfIssue[] = {  {&_swigt__p_FIX__DerivativeCountryOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEncodedIssuer[] = {  {&_swigt__p_FIX__DerivativeEncodedIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEncodedIssuerLen[] = {  {&_swigt__p_FIX__DerivativeEncodedIssuerLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEncodedSecurityDesc[] = {  {&_swigt__p_FIX__DerivativeEncodedSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEncodedSecurityDescLen[] = {  {&_swigt__p_FIX__DerivativeEncodedSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventDate[] = {  {&_swigt__p_FIX__DerivativeEventDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventPx[] = {  {&_swigt__p_FIX__DerivativeEventPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventText[] = {  {&_swigt__p_FIX__DerivativeEventText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventTime[] = {  {&_swigt__p_FIX__DerivativeEventTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeEventType[] = {  {&_swigt__p_FIX__DerivativeEventType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeExerciseStyle[] = {  {&_swigt__p_FIX__DerivativeExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeFloorPrice[] = {  {&_swigt__p_FIX__DerivativeFloorPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeFlowScheduleType[] = {  {&_swigt__p_FIX__DerivativeFlowScheduleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeFuturesValuationMethod[] = {  {&_swigt__p_FIX__DerivativeFuturesValuationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrAttribType[] = {  {&_swigt__p_FIX__DerivativeInstrAttribType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrAttribValue[] = {  {&_swigt__p_FIX__DerivativeInstrAttribValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrRegistry[] = {  {&_swigt__p_FIX__DerivativeInstrRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrmtAssignmentMethod[] = {  {&_swigt__p_FIX__DerivativeInstrmtAssignmentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartyID[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartyIDSource[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartyRole[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartySubID[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeInstrumentPartySubIDType[] = {  {&_swigt__p_FIX__DerivativeInstrumentPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeIssueDate[] = {  {&_swigt__p_FIX__DerivativeIssueDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeIssuer[] = {  {&_swigt__p_FIX__DerivativeIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeListMethod[] = {  {&_swigt__p_FIX__DerivativeListMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeLocaleOfIssue[] = {  {&_swigt__p_FIX__DerivativeLocaleOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMaturityDate[] = {  {&_swigt__p_FIX__DerivativeMaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMaturityMonthYear[] = {  {&_swigt__p_FIX__DerivativeMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMaturityTime[] = {  {&_swigt__p_FIX__DerivativeMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMinPriceIncrement[] = {  {&_swigt__p_FIX__DerivativeMinPriceIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeMinPriceIncrementAmount[] = {  {&_swigt__p_FIX__DerivativeMinPriceIncrementAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeNTPositionLimit[] = {  {&_swigt__p_FIX__DerivativeNTPositionLimit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeOptAttribute[] = {  {&_swigt__p_FIX__DerivativeOptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeOptPayAmount[] = {  {&_swigt__p_FIX__DerivativeOptPayAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePositionLimit[] = {  {&_swigt__p_FIX__DerivativePositionLimit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePriceQuoteMethod[] = {  {&_swigt__p_FIX__DerivativePriceQuoteMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePriceUnitOfMeasure[] = {  {&_swigt__p_FIX__DerivativePriceUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePriceUnitOfMeasureQty[] = {  {&_swigt__p_FIX__DerivativePriceUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeProduct[] = {  {&_swigt__p_FIX__DerivativeProduct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeProductComplex[] = {  {&_swigt__p_FIX__DerivativeProductComplex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativePutOrCall[] = {  {&_swigt__p_FIX__DerivativePutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityAltID[] = {  {&_swigt__p_FIX__DerivativeSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityAltIDSource[] = {  {&_swigt__p_FIX__DerivativeSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityDesc[] = {  {&_swigt__p_FIX__DerivativeSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityExchange[] = {  {&_swigt__p_FIX__DerivativeSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityGroup[] = {  {&_swigt__p_FIX__DerivativeSecurityGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityID[] = {  {&_swigt__p_FIX__DerivativeSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityIDSource[] = {  {&_swigt__p_FIX__DerivativeSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityStatus[] = {  {&_swigt__p_FIX__DerivativeSecurityStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecuritySubType[] = {  {&_swigt__p_FIX__DerivativeSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityType[] = {  {&_swigt__p_FIX__DerivativeSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityXML[] = {  {&_swigt__p_FIX__DerivativeSecurityXML, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityXMLLen[] = {  {&_swigt__p_FIX__DerivativeSecurityXMLLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSecurityXMLSchema[] = {  {&_swigt__p_FIX__DerivativeSecurityXMLSchema, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSettlMethod[] = {  {&_swigt__p_FIX__DerivativeSettlMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSettleOnOpenFlag[] = {  {&_swigt__p_FIX__DerivativeSettleOnOpenFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStateOrProvinceOfIssue[] = {  {&_swigt__p_FIX__DerivativeStateOrProvinceOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStrikeCurrency[] = {  {&_swigt__p_FIX__DerivativeStrikeCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStrikeMultiplier[] = {  {&_swigt__p_FIX__DerivativeStrikeMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStrikePrice[] = {  {&_swigt__p_FIX__DerivativeStrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeStrikeValue[] = {  {&_swigt__p_FIX__DerivativeStrikeValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSymbol[] = {  {&_swigt__p_FIX__DerivativeSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeSymbolSfx[] = {  {&_swigt__p_FIX__DerivativeSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeTimeUnit[] = {  {&_swigt__p_FIX__DerivativeTimeUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeUnitOfMeasure[] = {  {&_swigt__p_FIX__DerivativeUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeUnitOfMeasureQty[] = {  {&_swigt__p_FIX__DerivativeUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DerivativeValuationMethod[] = {  {&_swigt__p_FIX__DerivativeValuationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Designation[] = {  {&_swigt__p_FIX__Designation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeskID[] = {  {&_swigt__p_FIX__DeskID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeskOrderHandlingInst[] = {  {&_swigt__p_FIX__DeskOrderHandlingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeskType[] = {  {&_swigt__p_FIX__DeskType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DeskTypeSource[] = {  {&_swigt__p_FIX__DeskTypeSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DetachmentPoint[] = {  {&_swigt__p_FIX__DetachmentPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Dictionary[] = {  {&_swigt__p_FIX__Dictionary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Dictionary__Data__const_iterator[] = {  {&_swigt__p_FIX__Dictionary__Data__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionInst[] = {  {&_swigt__p_FIX__DiscretionInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionLimitType[] = {  {&_swigt__p_FIX__DiscretionLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionMoveType[] = {  {&_swigt__p_FIX__DiscretionMoveType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionOffset[] = {  {&_swigt__p_FIX__DiscretionOffset, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionOffsetType[] = {  {&_swigt__p_FIX__DiscretionOffsetType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionOffsetValue[] = {  {&_swigt__p_FIX__DiscretionOffsetValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionPrice[] = {  {&_swigt__p_FIX__DiscretionPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionRoundDirection[] = {  {&_swigt__p_FIX__DiscretionRoundDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DiscretionScope[] = {  {&_swigt__p_FIX__DiscretionScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayHighQty[] = {  {&_swigt__p_FIX__DisplayHighQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayLowQty[] = {  {&_swigt__p_FIX__DisplayLowQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayMethod[] = {  {&_swigt__p_FIX__DisplayMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayMinIncr[] = {  {&_swigt__p_FIX__DisplayMinIncr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayQty[] = {  {&_swigt__p_FIX__DisplayQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DisplayWhen[] = {  {&_swigt__p_FIX__DisplayWhen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DistribPaymentMethod[] = {  {&_swigt__p_FIX__DistribPaymentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DistribPercentage[] = {  {&_swigt__p_FIX__DistribPercentage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DividendYield[] = {  {&_swigt__p_FIX__DividendYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DlvyInst[] = {  {&_swigt__p_FIX__DlvyInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DlvyInstType[] = {  {&_swigt__p_FIX__DlvyInstType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DoNotSend[] = {  {&_swigt__p_FIX__DoNotSend, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DoubleField[] = {  {&_swigt__p_FIX__DerivativeUnitOfMeasureQty, _p_FIX__DerivativeUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegPriceUnitOfMeasureQty, _p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingUnitOfMeasureQty, _p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnitOfMeasureQty, _p_FIX__UnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativePriceUnitOfMeasureQty, _p_FIX__DerivativePriceUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty, _p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PriceUnitOfMeasureQty, _p_FIX__PriceUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegUnitOfMeasureQty, _p_FIX__LegUnitOfMeasureQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingLastPx, _p_FIX__UnderlyingLastPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegLastPx, _p_FIX__LegLastPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastPx, _p_FIX__LastPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ReportedPx, _p_FIX__ReportedPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCapValue, _p_FIX__UnderlyingCapValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MidPx, _p_FIX__MidPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DisplayLowQty, _p_FIX__DisplayLowQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RoundingModulus, _p_FIX__RoundingModulusTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegRatioQty, _p_FIX__LegRatioQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RatioQty, _p_FIX__RatioQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDEntrySize, _p_FIX__MDEntrySizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ComplexEventPrice, _p_FIX__ComplexEventPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LeavesQty, _p_FIX__LeavesQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Quantity, _p_FIX__QuantityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingAdjustedQuantity, _p_FIX__UnderlyingAdjustedQuantityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TotalTakedown, _p_FIX__TotalTakedownTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DisplayMinIncr, _p_FIX__DisplayMinIncrTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Factor, _p_FIX__FactorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingFactor, _p_FIX__UnderlyingFactorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegFactor, _p_FIX__LegFactorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AccruedInterestAmt, _p_FIX__AccruedInterestAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TotalAccruedInterestAmt, _p_FIX__TotalAccruedInterestAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocAccruedInterestAmt, _p_FIX__AllocAccruedInterestAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EndAccruedInterestAmt, _p_FIX__EndAccruedInterestAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeFloorPrice, _p_FIX__DerivativeFloorPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TriggerPrice, _p_FIX__TriggerPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FloorPrice, _p_FIX__FloorPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RndPx, _p_FIX__RndPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ThresholdAmount, _p_FIX__ThresholdAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCashAmount, _p_FIX__UnderlyingCashAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeMinPriceIncrementAmount, _p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ComplexOptPayoutAmount, _p_FIX__ComplexOptPayoutAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCollectAmount, _p_FIX__UnderlyingCollectAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OptPayoutAmount, _p_FIX__OptPayoutAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinPriceIncrementAmount, _p_FIX__MinPriceIncrementAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingDirtyPrice, _p_FIX__UnderlyingDirtyPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AvgParPx, _p_FIX__AvgParPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ShortQty, _p_FIX__ShortQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocAvgPx, _p_FIX__AllocAvgPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TriggerNewPrice, _p_FIX__TriggerNewPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PeggedRefPrice, _p_FIX__PeggedRefPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ContraTradeQty, _p_FIX__ContraTradeQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderBookingQty, _p_FIX__OrderBookingQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingQty, _p_FIX__UnderlyingQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Commission, _p_FIX__CommissionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SharedCommission, _p_FIX__SharedCommissionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DayAvgPx, _p_FIX__DayAvgPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SpreadToBenchmark, _p_FIX__SpreadToBenchmarkTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RepurchaseRate, _p_FIX__RepurchaseRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingRepurchaseRate, _p_FIX__UnderlyingRepurchaseRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegRepurchaseRate, _p_FIX__LegRepurchaseRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AttachmentPoint, _p_FIX__AttachmentPointTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingAttachmentPoint, _p_FIX__UnderlyingAttachmentPointTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DetachmentPoint, _p_FIX__DetachmentPointTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingDetachmentPoint, _p_FIX__UnderlyingDetachmentPointTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegOptionRatio, _p_FIX__LegOptionRatioTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MarginRatio, _p_FIX__MarginRatioTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingEndValue, _p_FIX__UnderlyingEndValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidPx, _p_FIX__BidPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeMultiplier, _p_FIX__DerivativeStrikeMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikeMultiplier, _p_FIX__StrikeMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ContractMultiplier, _p_FIX__ContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegContractMultiplier, _p_FIX__LegContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingContractMultiplier, _p_FIX__UnderlyingContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FeeMultiplier, _p_FIX__FeeMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeContractMultiplier, _p_FIX__DerivativeContractMultiplierTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessValue, _p_FIX__AllowableOneSidednessValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TimeToExpiration, _p_FIX__TimeToExpirationTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferForwardPoints, _p_FIX__OfferForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDEntryForwardPoints, _p_FIX__MDEntryForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidForwardPoints, _p_FIX__BidForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferSwapPoints, _p_FIX__OfferSwapPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidSwapPoints, _p_FIX__BidSwapPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegOfferForwardPoints, _p_FIX__LegOfferForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegLastForwardPoints, _p_FIX__LegLastForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SwapPoints, _p_FIX__SwapPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastForwardPoints, _p_FIX__LastForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegBidForwardPoints, _p_FIX__LegBidForwardPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastSwapPoints, _p_FIX__LastSwapPointsTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__GrossTradeAmt, _p_FIX__GrossTradeAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SideGrossTradeAmt, _p_FIX__SideGrossTradeAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegGrossTradeAmt, _p_FIX__LegGrossTradeAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StopPx, _p_FIX__StopPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingFXRate, _p_FIX__UnderlyingFXRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__NetChgPrevDay, _p_FIX__NetChgPrevDayTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingDeliveryAmount, _p_FIX__UnderlyingDeliveryAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeOptPayAmount, _p_FIX__DerivativeOptPayAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingPayAmount, _p_FIX__UnderlyingPayAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OptPayAmount, _p_FIX__OptPayAmountTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CapPrice, _p_FIX__CapPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeCapPrice, _p_FIX__DerivativeCapPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferPx, _p_FIX__OfferPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MktOfferPx, _p_FIX__MktOfferPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegOfferPx, _p_FIX__LegOfferPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferYield, _p_FIX__OfferYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Price, _p_FIX__PriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PegDifference, _p_FIX__PegDifferenceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinQty, _p_FIX__MinQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MiscFeeAmt, _p_FIX__MiscFeeAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderAvgPx, _p_FIX__OrderAvgPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastParPx, _p_FIX__LastParPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PriceImprovement, _p_FIX__PriceImprovementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessPct, _p_FIX__AllowableOneSidednessPctTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OutsideIndexPct, _p_FIX__OutsideIndexPctTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SellVolume, _p_FIX__SellVolumeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PeggedPrice, _p_FIX__PeggedPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PrevClosePx, _p_FIX__PrevClosePxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EndStrikePxRange, _p_FIX__EndStrikePxRangeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StartStrikePxRange, _p_FIX__StartStrikePxRangeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastQty, _p_FIX__LastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegCalculatedCcyLastQty, _p_FIX__LegCalculatedCcyLastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegLastQty, _p_FIX__LegLastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CalculatedCcyLastQty, _p_FIX__CalculatedCcyLastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingLastQty, _p_FIX__UnderlyingLastQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastForwardPoints2, _p_FIX__LastForwardPoints2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferForwardPoints2, _p_FIX__OfferForwardPoints2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidForwardPoints2, _p_FIX__BidForwardPoints2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingPx, _p_FIX__UnderlyingPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SecondaryDisplayQty, _p_FIX__SecondaryDisplayQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DisplayQty, _p_FIX__DisplayQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BenchmarkPrice, _p_FIX__BenchmarkPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkPrice, _p_FIX__LegBenchmarkPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderQty2, _p_FIX__OrderQty2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StartTickPriceRange, _p_FIX__StartTickPriceRangeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EndTickPriceRange, _p_FIX__EndTickPriceRangeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DiscretionOffset, _p_FIX__DiscretionOffsetTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ParticipationRate, _p_FIX__ParticipationRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LiquidityPctLow, _p_FIX__LiquidityPctLowTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocQty, _p_FIX__AllocQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegAllocQty, _p_FIX__LegAllocQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__HighPx, _p_FIX__HighPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DoubleField, 0, 0, 0},  {&_swigt__p_FIX__FirstPx, _p_FIX__FirstPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDEntrySpotRate, _p_FIX__MDEntrySpotRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidSpotRate, _p_FIX__BidSpotRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferSpotRate, _p_FIX__OfferSpotRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastSpotRate, _p_FIX__LastSpotRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TargetStrategyPerformance, _p_FIX__TargetStrategyPerformanceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CashOutstanding, _p_FIX__CashOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingNotionalPercentageOutstanding, _p_FIX__UnderlyingNotionalPercentageOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__NotionalPercentageOutstanding, _p_FIX__NotionalPercentageOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OriginalNotionalPercentageOutstanding, _p_FIX__OriginalNotionalPercentageOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DiscretionPrice, _p_FIX__DiscretionPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__YieldRedemptionPrice, _p_FIX__YieldRedemptionPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlCurrAmt, _p_FIX__SettlCurrAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocSettlCurrAmt, _p_FIX__AllocSettlCurrAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Yield, _p_FIX__YieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TradeVolume, _p_FIX__TradeVolumeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BuyVolume, _p_FIX__BuyVolumeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingEndPrice, _p_FIX__UnderlyingEndPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikeValue, _p_FIX__StrikeValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeValue, _p_FIX__DerivativeStrikeValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DisplayHighQty, _p_FIX__DisplayHighQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AvgPx, _p_FIX__AvgPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlCurrFxRate, _p_FIX__SettlCurrFxRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlCurrOfferFxRate, _p_FIX__SettlCurrOfferFxRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlCurrBidFxRate, _p_FIX__SettlCurrBidFxRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding, _p_FIX__UnderlyingOriginalNotionalPercentageOutstandingTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MidYield, _p_FIX__MidYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidYield, _p_FIX__BidYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinTradeVol, _p_FIX__MinTradeVolTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaxTradeVol, _p_FIX__MaxTradeVolTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegBidPx, _p_FIX__LegBidPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FillQty, _p_FIX__FillQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Spread, _p_FIX__SpreadTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EndCash, _p_FIX__EndCashTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Concession, _p_FIX__ConcessionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCouponRate, _p_FIX__UnderlyingCouponRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LastShares, _p_FIX__LastSharesTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CouponRate, _p_FIX__CouponRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegCouponRate, _p_FIX__LegCouponRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegPrice, _p_FIX__LegPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AssignmentUnit, _p_FIX__AssignmentUnitTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OutMainCntryUIndex, _p_FIX__OutMainCntryUIndexTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaxShow, _p_FIX__MaxShowTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LowPx, _p_FIX__LowPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RoundLot, _p_FIX__RoundLotTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RiskFreeRate, _p_FIX__RiskFreeRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderCapacityQty, _p_FIX__OrderCapacityQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PctAtRisk, _p_FIX__PctAtRiskTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__RefreshQty, _p_FIX__RefreshQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PosAmt, _p_FIX__PosAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MarginExcess, _p_FIX__MarginExcessTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PegOffsetValue, _p_FIX__PegOffsetValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ContAmtValue, _p_FIX__ContAmtValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DiscretionOffsetValue, _p_FIX__DiscretionOffsetValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TotalNetValue, _p_FIX__TotalNetValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinPriceIncrement, _p_FIX__MinPriceIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeMinPriceIncrement, _p_FIX__DerivativeMinPriceIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TickIncrement, _p_FIX__TickIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MatchIncrement, _p_FIX__MatchIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikeIncrement, _p_FIX__StrikeIncrementTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DividendYield, _p_FIX__DividendYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegDividendYield, _p_FIX__LegDividendYieldTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDEntryPx, _p_FIX__MDEntryPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaxFloor, _p_FIX__MaxFloorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocInterestAtMaturity, _p_FIX__AllocInterestAtMaturityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__InterestAtMaturity, _p_FIX__InterestAtMaturityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaxPriceVariation, _p_FIX__MaxPriceVariationTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CcyAmt, _p_FIX__CcyAmtTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Shares, _p_FIX__SharesTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocShares, _p_FIX__AllocSharesTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EventPx, _p_FIX__EventPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeEventPx, _p_FIX__DerivativeEventPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PriceDelta, _p_FIX__PriceDeltaTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegVolatility, _p_FIX__LegVolatilityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Volatility, _p_FIX__VolatilityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegQty, _p_FIX__LegQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinBidSize, _p_FIX__MinBidSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DefBidSize, _p_FIX__DefBidSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BidSize, _p_FIX__BidSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegStrikePrice, _p_FIX__LegStrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DerivativeStrikePrice, _p_FIX__DerivativeStrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SecondaryTradingReferencePrice, _p_FIX__SecondaryTradingReferencePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TradingReferencePrice, _p_FIX__TradingReferencePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikePrice, _p_FIX__StrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingStrikePrice, _p_FIX__UnderlyingStrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegStrikePrice, _p_FIX__UnderlyingLegStrikePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CurrencyRatio, _p_FIX__CurrencyRatioTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegCurrencyRatio, _p_FIX__LegCurrencyRatioTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SettlPrice, _p_FIX__SettlPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlPrice, _p_FIX__UnderlyingSettlPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__PriorSettlPrice, _p_FIX__PriorSettlPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OpenInterest, _p_FIX__OpenInterestTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DistribPercentage, _p_FIX__DistribPercentageTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ExpQty, _p_FIX__ExpQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LegOrderQty, _p_FIX__LegOrderQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CashOrderQty, _p_FIX__CashOrderQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DayOrderQty, _p_FIX__DayOrderQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderQty, _p_FIX__OrderQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocNetMoney, _p_FIX__AllocNetMoneyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__NetMoney, _p_FIX__NetMoneyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MaturityNetMoney, _p_FIX__MaturityNetMoneyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LongQty, _p_FIX__LongQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ExecPriceAdjustment, _p_FIX__ExecPriceAdjustmentTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingStartValue, _p_FIX__UnderlyingStartValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingCurrentValue, _p_FIX__UnderlyingCurrentValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinOfferSize, _p_FIX__MinOfferSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OfferSize, _p_FIX__OfferSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DefOfferSize, _p_FIX__DefOfferSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FairValue, _p_FIX__FairValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CxlQty, _p_FIX__CxlQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SideValue1, _p_FIX__SideValue1To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SideValue2, _p_FIX__SideValue2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MktBidPx, _p_FIX__MktBidPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LiquidityValue, _p_FIX__LiquidityValueTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StartCash, _p_FIX__StartCashTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__WtAverageLiquidity, _p_FIX__WtAverageLiquidityTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TotalVolumeTraded, _p_FIX__TotalVolumeTradedTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__FillPx, _p_FIX__FillPxTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__BasisFeaturePrice, _p_FIX__BasisFeaturePriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__EFPTrackingError, _p_FIX__EFPTrackingErrorTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__TriggerNewQty, _p_FIX__TriggerNewQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__Price2, _p_FIX__Price2To_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceBoundaryPrecision, _p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__StrikePriceBoundaryPrecision, _p_FIX__StrikePriceBoundaryPrecisionTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SecondaryLowLimitPrice, _p_FIX__SecondaryLowLimitPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__SecondaryHighLimitPrice, _p_FIX__SecondaryHighLimitPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__HighLimitPrice, _p_FIX__HighLimitPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LowLimitPrice, _p_FIX__LowLimitPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MinLotSize, _p_FIX__MinLotSizeTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AllocPrice, _p_FIX__AllocPriceTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__ValueOfFutures, _p_FIX__ValueOfFuturesTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CumQty, _p_FIX__CumQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__DayCumQty, _p_FIX__DayCumQtyTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__LiquidityPctHigh, _p_FIX__LiquidityPctHighTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__CrossPercent, _p_FIX__CrossPercentTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__OrderPercent, _p_FIX__OrderPercentTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__UnderlyingAllocationPercent, _p_FIX__UnderlyingAllocationPercentTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__AccruedInterestRate, _p_FIX__AccruedInterestRateTo_p_FIX__DoubleField, 0, 0},  {&_swigt__p_FIX__MDSecSize, _p_FIX__MDSecSizeTo_p_FIX__DoubleField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DueToRelated[] = {  {&_swigt__p_FIX__DueToRelated, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__DuplicateFieldNumber[] = {  {&_swigt__p_FIX__DuplicateFieldNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EFPTrackingError[] = {  {&_swigt__p_FIX__EFPTrackingError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EXCHANGE[] = {  {&_swigt__p_FIX__EXCHANGE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EffectiveTime[] = {  {&_swigt__p_FIX__EffectiveTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EmailThreadID[] = {  {&_swigt__p_FIX__EmailThreadID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EmailType[] = {  {&_swigt__p_FIX__EmailType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedAllocText[] = {  {&_swigt__p_FIX__EncodedAllocText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedAllocTextLen[] = {  {&_swigt__p_FIX__EncodedAllocTextLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedHeadline[] = {  {&_swigt__p_FIX__EncodedHeadline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedHeadlineLen[] = {  {&_swigt__p_FIX__EncodedHeadlineLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedIssuer[] = {  {&_swigt__p_FIX__EncodedIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedIssuerLen[] = {  {&_swigt__p_FIX__EncodedIssuerLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedLegIssuer[] = {  {&_swigt__p_FIX__EncodedLegIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedLegIssuerLen[] = {  {&_swigt__p_FIX__EncodedLegIssuerLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedLegSecurityDesc[] = {  {&_swigt__p_FIX__EncodedLegSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedLegSecurityDescLen[] = {  {&_swigt__p_FIX__EncodedLegSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedListExecInst[] = {  {&_swigt__p_FIX__EncodedListExecInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedListExecInstLen[] = {  {&_swigt__p_FIX__EncodedListExecInstLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedListStatusText[] = {  {&_swigt__p_FIX__EncodedListStatusText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedListStatusTextLen[] = {  {&_swigt__p_FIX__EncodedListStatusTextLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedMktSegmDesc[] = {  {&_swigt__p_FIX__EncodedMktSegmDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedMktSegmDescLen[] = {  {&_swigt__p_FIX__EncodedMktSegmDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSecurityDesc[] = {  {&_swigt__p_FIX__EncodedSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSecurityDescLen[] = {  {&_swigt__p_FIX__EncodedSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSecurityListDesc[] = {  {&_swigt__p_FIX__EncodedSecurityListDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSecurityListDescLen[] = {  {&_swigt__p_FIX__EncodedSecurityListDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSubject[] = {  {&_swigt__p_FIX__EncodedSubject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedSubjectLen[] = {  {&_swigt__p_FIX__EncodedSubjectLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedText[] = {  {&_swigt__p_FIX__EncodedText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedTextLen[] = {  {&_swigt__p_FIX__EncodedTextLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedUnderlyingIssuer[] = {  {&_swigt__p_FIX__EncodedUnderlyingIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedUnderlyingIssuerLen[] = {  {&_swigt__p_FIX__EncodedUnderlyingIssuerLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedUnderlyingSecurityDesc[] = {  {&_swigt__p_FIX__EncodedUnderlyingSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncodedUnderlyingSecurityDescLen[] = {  {&_swigt__p_FIX__EncodedUnderlyingSecurityDescLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptMethod[] = {  {&_swigt__p_FIX__EncryptMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedNewPassword[] = {  {&_swigt__p_FIX__EncryptedNewPassword, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedNewPasswordLen[] = {  {&_swigt__p_FIX__EncryptedNewPasswordLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedPassword[] = {  {&_swigt__p_FIX__EncryptedPassword, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedPasswordLen[] = {  {&_swigt__p_FIX__EncryptedPasswordLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EncryptedPasswordMethod[] = {  {&_swigt__p_FIX__EncryptedPasswordMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndAccruedInterestAmt[] = {  {&_swigt__p_FIX__EndAccruedInterestAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndCash[] = {  {&_swigt__p_FIX__EndCash, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndDate[] = {  {&_swigt__p_FIX__EndDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndMaturityMonthYear[] = {  {&_swigt__p_FIX__EndMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndSeqNo[] = {  {&_swigt__p_FIX__EndSeqNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndStrikePxRange[] = {  {&_swigt__p_FIX__EndStrikePxRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EndTickPriceRange[] = {  {&_swigt__p_FIX__EndTickPriceRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventDate[] = {  {&_swigt__p_FIX__EventDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventPx[] = {  {&_swigt__p_FIX__EventPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventText[] = {  {&_swigt__p_FIX__EventText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventTime[] = {  {&_swigt__p_FIX__EventTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__EventType[] = {  {&_swigt__p_FIX__EventType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExDate[] = {  {&_swigt__p_FIX__ExDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExDestination[] = {  {&_swigt__p_FIX__ExDestination, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExDestinationIDSource[] = {  {&_swigt__p_FIX__ExDestinationIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Exception[] = {  {&_swigt__p_FIX__RequiredTagMissing, _p_FIX__RequiredTagMissingTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketSendFailed, _p_FIX__SocketSendFailedTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketRecvFailed, _p_FIX__SocketRecvFailedTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__InvalidTagNumber, _p_FIX__InvalidTagNumberTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RejectLogon, _p_FIX__RejectLogonTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__IncorrectDataFormat, _p_FIX__IncorrectDataFormatTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__TagNotDefinedForMessage, _p_FIX__TagNotDefinedForMessageTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__InvalidMessage, _p_FIX__InvalidMessageTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__DoNotSend, _p_FIX__DoNotSendTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RuntimeError, _p_FIX__RuntimeErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__MessageParseError, _p_FIX__MessageParseErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__DuplicateFieldNumber, _p_FIX__DuplicateFieldNumberTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__FieldNotFound, _p_FIX__FieldNotFoundTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__DataDictionaryNotFound, _p_FIX__DataDictionaryNotFoundTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SessionNotFound, _p_FIX__SessionNotFoundTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__Exception, 0, 0, 0},  {&_swigt__p_FIX__IOException, _p_FIX__IOExceptionTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketException, _p_FIX__SocketExceptionTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__ConfigError, _p_FIX__ConfigErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__InvalidMessageType, _p_FIX__InvalidMessageTypeTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__UnsupportedMessageType, _p_FIX__UnsupportedMessageTypeTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__UnsupportedVersion, _p_FIX__UnsupportedVersionTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__IncorrectTagValue, _p_FIX__IncorrectTagValueTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__NoTagValue, _p_FIX__NoTagValueTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__SocketCloseFailed, _p_FIX__SocketCloseFailedTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__TagOutOfOrder, _p_FIX__TagOutOfOrderTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RepeatedTag, _p_FIX__RepeatedTagTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__FieldConvertError, _p_FIX__FieldConvertErrorTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__IncorrectMessageStructure, _p_FIX__IncorrectMessageStructureTo_p_FIX__Exception, 0, 0},  {&_swigt__p_FIX__RepeatingGroupCountMismatch, _p_FIX__RepeatingGroupCountMismatchTo_p_FIX__Exception, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExchangeForPhysical[] = {  {&_swigt__p_FIX__ExchangeForPhysical, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExchangeRule[] = {  {&_swigt__p_FIX__ExchangeRule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExchangeSpecialInstructions[] = {  {&_swigt__p_FIX__ExchangeSpecialInstructions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecAckStatus[] = {  {&_swigt__p_FIX__ExecAckStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecBroker[] = {  {&_swigt__p_FIX__ExecBroker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecID[] = {  {&_swigt__p_FIX__ExecID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecInst[] = {  {&_swigt__p_FIX__ExecInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecInstValue[] = {  {&_swigt__p_FIX__ExecInstValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecPriceAdjustment[] = {  {&_swigt__p_FIX__ExecPriceAdjustment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecPriceType[] = {  {&_swigt__p_FIX__ExecPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecRefID[] = {  {&_swigt__p_FIX__ExecRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecRestatementReason[] = {  {&_swigt__p_FIX__ExecRestatementReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecTransType[] = {  {&_swigt__p_FIX__ExecTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecType[] = {  {&_swigt__p_FIX__ExecType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExecValuationPoint[] = {  {&_swigt__p_FIX__ExecValuationPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExerciseMethod[] = {  {&_swigt__p_FIX__ExerciseMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExerciseStyle[] = {  {&_swigt__p_FIX__ExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpQty[] = {  {&_swigt__p_FIX__ExpQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpType[] = {  {&_swigt__p_FIX__ExpType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpirationCycle[] = {  {&_swigt__p_FIX__ExpirationCycle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpirationQtyType[] = {  {&_swigt__p_FIX__ExpirationQtyType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpireDate[] = {  {&_swigt__p_FIX__ExpireDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ExpireTime[] = {  {&_swigt__p_FIX__ExpireTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FLOAT[] = {  {&_swigt__p_FIX__FLOAT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Factor[] = {  {&_swigt__p_FIX__Factor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FairValue[] = {  {&_swigt__p_FIX__FairValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FeeMultiplier[] = {  {&_swigt__p_FIX__FeeMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldBase[] = {  {&_swigt__p_FIX__CFICode, _p_FIX__CFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCFICode, _p_FIX__UnderlyingCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeCFICode, _p_FIX__DerivativeCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCFICode, _p_FIX__LegCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegCFICode, _p_FIX__UnderlyingLegCFICodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearFormat, _p_FIX__MaturityMonthYearFormatTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartCash, _p_FIX__StartCashTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasure, _p_FIX__UnderlyingPriceUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingUnitOfMeasure, _p_FIX__UnderlyingUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegUnitOfMeasure, _p_FIX__LegUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceUnitOfMeasure, _p_FIX__PriceUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnitOfMeasure, _p_FIX__UnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPriceUnitOfMeasure, _p_FIX__LegPriceUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeUnitOfMeasure, _p_FIX__DerivativeUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePriceUnitOfMeasure, _p_FIX__DerivativePriceUnitOfMeasureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigTradeID, _p_FIX__OrigTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FirmTradeID, _p_FIX__FirmTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryFirmTradeID, _p_FIX__SecondaryFirmTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeID, _p_FIX__TradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTradeID, _p_FIX__SecondaryTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigSecondaryTradeID, _p_FIX__OrigSecondaryTradeIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Yield, _p_FIX__YieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityType, _p_FIX__UnderlyingSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityType, _p_FIX__SecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RepoCollateralSecurityType, _p_FIX__RepoCollateralSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRepoCollateralSecurityType, _p_FIX__LegRepoCollateralSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpirationQtyType, _p_FIX__ExpirationQtyTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityType, _p_FIX__LegSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuantityType, _p_FIX__QuantityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityType, _p_FIX__DerivativeSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRepoCollateralSecurityType, _p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QtyType, _p_FIX__QtyTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityType, _p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Account, _p_FIX__AccountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingAccount, _p_FIX__ClearingAccountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocAccount, _p_FIX__LegAllocAccountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAccount, _p_FIX__AllocAccountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDImplicitDelete, _p_FIX__MDImplicitDeleteTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegTimeUnit, _p_FIX__LegTimeUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TimeUnit, _p_FIX__TimeUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeTimeUnit, _p_FIX__DerivativeTimeUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingTimeUnit, _p_FIX__UnderlyingTimeUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StandInstDbID, _p_FIX__StandInstDbIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NotifyBrokerOfCredit, _p_FIX__NotifyBrokerOfCreditTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BrokerOfCredit, _p_FIX__BrokerOfCreditTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecuritySubType, _p_FIX__UnderlyingSecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecuritySubType, _p_FIX__LegSecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecuritySubType, _p_FIX__DerivativeSecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySubType, _p_FIX__SecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecuritySubType, _p_FIX__UnderlyingLegSecuritySubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdSubType, _p_FIX__TrdSubTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ShortSaleReason, _p_FIX__ShortSaleReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeleteReason, _p_FIX__DeleteReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocCancReplaceReason, _p_FIX__AllocCancReplaceReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DKReason, _p_FIX__DKReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetworkRequestID, _p_FIX__NetworkRequestIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UserRequestID, _p_FIX__UserRequestIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeRequestID, _p_FIX__TradeRequestIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarginExcess, _p_FIX__MarginExcessTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistRejReasonText, _p_FIX__RegistRejReasonTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraTradeTime, _p_FIX__ContraTradeTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoEvents, _p_FIX__NoEventsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeEvents, _p_FIX__NoDerivativeEventsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLastQty, _p_FIX__UnderlyingLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CalculatedCcyLastQty, _p_FIX__CalculatedCcyLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideLastQty, _p_FIX__SideLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCalculatedCcyLastQty, _p_FIX__LegCalculatedCcyLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegLastQty, _p_FIX__LegLastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastQty, _p_FIX__LastQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CheckSumField, _p_FIX__CheckSumFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Username, _p_FIX__UsernameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintRptID, _p_FIX__PosMaintRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContIntRptID, _p_FIX__ContIntRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeValue, _p_FIX__DerivativeStrikeValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeValue, _p_FIX__StrikeValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OptPayoutType, _p_FIX__OptPayoutTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedText, _p_FIX__EncodedTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__GapFillFlag, _p_FIX__GapFillFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketDepth, _p_FIX__MarketDepthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StopPx, _p_FIX__StopPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDPriceLevel, _p_FIX__MDPriceLevelTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteResponseLevel, _p_FIX__QuoteResponseLevelTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldCalcDate, _p_FIX__YieldCalcDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollRptID, _p_FIX__CollRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegNumber, _p_FIX__LegNumberTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosType, _p_FIX__PosTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContAmtType, _p_FIX__ContAmtTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosAmtType, _p_FIX__PosAmtTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstID, _p_FIX__SettlInstIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReportedPx, _p_FIX__ReportedPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastFragment, _p_FIX__LastFragmentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceLimitType, _p_FIX__PriceLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegLimitType, _p_FIX__PegLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryPriceLimitType, _p_FIX__SecondaryPriceLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionLimitType, _p_FIX__DiscretionLimitTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLegStipulations, _p_FIX__NoLegStipulationsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStipulations, _p_FIX__NoStipulationsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ShortQty, _p_FIX__ShortQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SellerDays, _p_FIX__SellerDaysTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RptSeq, _p_FIX__RptSeqTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionOffsetType, _p_FIX__DiscretionOffsetTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegOffsetType, _p_FIX__PegOffsetTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesEndTime, _p_FIX__TradSesEndTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventEndTime, _p_FIX__ComplexEventEndTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TierCode, _p_FIX__TierCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Benchmark, _p_FIX__BenchmarkTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SpreadToBenchmark, _p_FIX__SpreadToBenchmarkTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TransferReason, _p_FIX__TransferReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnRejectReason, _p_FIX__CollAsgnRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRequestRejectReason, _p_FIX__QuoteRequestRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SessionRejectReason, _p_FIX__SessionRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListRejectReason, _p_FIX__ListRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnReason, _p_FIX__CollAsgnReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRejectReason, _p_FIX__QuoteRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportRejectReason, _p_FIX__TradeReportRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnRejReason, _p_FIX__StreamAsgnRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteEntryRejectReason, _p_FIX__QuoteEntryRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecRestatementReason, _p_FIX__ExecRestatementReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrdRejReason, _p_FIX__OrdRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassCancelRejectReason, _p_FIX__MassCancelRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesStatusRejReason, _p_FIX__TradSesStatusRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CxlRejReason, _p_FIX__CxlRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmRejReason, _p_FIX__ConfirmRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionRejectReason, _p_FIX__MassActionRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefOrdIDReason, _p_FIX__RefOrdIDReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDReqRejReason, _p_FIX__MDReqRejReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BusinessRejectReason, _p_FIX__BusinessRejectReasonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocText, _p_FIX__AllocTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedAllocText, _p_FIX__EncodedAllocTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliverToSubID, _p_FIX__DeliverToSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MiscFeeCurr, _p_FIX__MiscFeeCurrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligMsgID, _p_FIX__SettlObligMsgIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReportedPxDiff, _p_FIX__ReportedPxDiffTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoComplexEvents, _p_FIX__NoComplexEventsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNestedInstrAttrib, _p_FIX__NoNestedInstrAttribTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoInstrAttrib, _p_FIX__NoInstrAttribTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrAttrib, _p_FIX__NoDerivativeInstrAttribTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTrdRepIndicators, _p_FIX__NoTrdRepIndicatorsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStatsIndicators, _p_FIX__NoStatsIndicatorsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoQuoteSets, _p_FIX__NoQuoteSetsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BeginSeqNo, _p_FIX__BeginSeqNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventPx, _p_FIX__EventPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventPx, _p_FIX__DerivativeEventPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityTradingEvent, _p_FIX__SecurityTradingEventTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CrossType, _p_FIX__CrossTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndStrikePxRange, _p_FIX__EndStrikePxRangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartStrikePxRange, _p_FIX__StartStrikePxRangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AgreementDesc, _p_FIX__AgreementDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketSegmentDesc, _p_FIX__MarketSegmentDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderDelay, _p_FIX__OrderDelayTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderCategory, _p_FIX__OrderCategoryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewsCategory, _p_FIX__NewsCategoryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinQty, _p_FIX__MinQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardNumber, _p_FIX__CardNumberTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribAgentAcctNumber, _p_FIX__CashDistribAgentAcctNumberTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPositions, _p_FIX__NoPositionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOfLegUnderlyings, _p_FIX__NoOfLegUnderlyingsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyings, _p_FIX__NoUnderlyingsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDates, _p_FIX__NoDatesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardStartDate, _p_FIX__CardStartDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartDate, _p_FIX__StartDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventStartDate, _p_FIX__ComplexEventStartDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefreshQty, _p_FIX__RefreshQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigTime, _p_FIX__OrigTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDUpdateType, _p_FIX__MDUpdateTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDQuoteType, _p_FIX__MDQuoteTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteType, _p_FIX__QuoteTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NumBidders, _p_FIX__NumBiddersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AgreementDate, _p_FIX__AgreementDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventDate, _p_FIX__EventDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCouponPaymentDate, _p_FIX__UnderlyingCouponPaymentDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PaymentDate, _p_FIX__PaymentDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementDate, _p_FIX__UnderlyingSettlementDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CouponPaymentDate, _p_FIX__CouponPaymentDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventDate, _p_FIX__DerivativeEventDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCouponPaymentDate, _p_FIX__LegCouponPaymentDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSymbolSfx, _p_FIX__UnderlyingSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSymbolSfx, _p_FIX__DerivativeSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SymbolSfx, _p_FIX__SymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSymbolSfx, _p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSymbolSfx, _p_FIX__LegSymbolSfxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdType, _p_FIX__TrdTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTrdType, _p_FIX__SecondaryTrdTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMsgTypes, _p_FIX__NoMsgTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerOrderType, _p_FIX__TriggerOrderTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrategyParameterType, _p_FIX__StrategyParameterTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OwnerType, _p_FIX__OwnerTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlSessSubID, _p_FIX__SettlSessSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TickRuleType, _p_FIX__TickRuleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingFlowScheduleType, _p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegFlowScheduleType, _p_FIX__LegFlowScheduleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeFlowScheduleType, _p_FIX__DerivativeFlowScheduleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FlowScheduleType, _p_FIX__FlowScheduleTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MiscFeeBasis, _p_FIX__MiscFeeBasisTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedTextLen, _p_FIX__EncodedTextLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedAllocTextLen, _p_FIX__EncodedAllocTextLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedListStatusTextLen, _p_FIX__EncodedListStatusTextLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesEvent, _p_FIX__TradSesEventTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayQty, _p_FIX__DisplayQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryDisplayQty, _p_FIX__SecondaryDisplayQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNumTradeReports, _p_FIX__TotNumTradeReportsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalNumPosReports, _p_FIX__TotalNumPosReportsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNumReports, _p_FIX__TotNumReportsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNumAssignmentReports, _p_FIX__TotNumAssignmentReportsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideSettlCurrency, _p_FIX__SideSettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurveCurrency, _p_FIX__LegBenchmarkCurveCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkCurveCurrency, _p_FIX__BenchmarkCurveCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocSettlCurrency, _p_FIX__LegAllocSettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSettlCurrency, _p_FIX__LegSettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingCurrency, _p_FIX__TradingCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeCurrency, _p_FIX__StrikeCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrency, _p_FIX__SettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Currency, _p_FIX__CurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCurrency, _p_FIX__LegCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideCurrency, _p_FIX__SideCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocSettlCurrency, _p_FIX__AllocSettlCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AgreementCurrency, _p_FIX__AgreementCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeCurrency, _p_FIX__DerivativeStrikeCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStrikeCurrency, _p_FIX__UnderlyingStrikeCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CommCurrency, _p_FIX__CommCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCurrency, _p_FIX__UnderlyingCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PositionCurrency, _p_FIX__PositionCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStrikeCurrency, _p_FIX__LegStrikeCurrencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeType, _p_FIX__TradeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidTradeType, _p_FIX__BidTradeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettleOnOpenFlag, _p_FIX__SettleOnOpenFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSettleOnOpenFlag, _p_FIX__DerivativeSettleOnOpenFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegLocaleOfIssue, _p_FIX__LegLocaleOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LocaleOfIssue, _p_FIX__LocaleOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCountryOfIssue, _p_FIX__UnderlyingCountryOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStateOrProvinceOfIssue, _p_FIX__LegStateOrProvinceOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeCountryOfIssue, _p_FIX__DerivativeCountryOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStateOrProvinceOfIssue, _p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStateOrProvinceOfIssue, _p_FIX__DerivativeStateOrProvinceOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCountryOfIssue, _p_FIX__LegCountryOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StateOrProvinceOfIssue, _p_FIX__StateOrProvinceOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CountryOfIssue, _p_FIX__CountryOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeLocaleOfIssue, _p_FIX__DerivativeLocaleOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLocaleOfIssue, _p_FIX__UnderlyingLocaleOfIssueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlInst, _p_FIX__NoSettlInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTradingSessions, _p_FIX__NoTradingSessionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Seniority, _p_FIX__SeniorityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSeniority, _p_FIX__UnderlyingSeniorityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CxlQty, _p_FIX__CxlQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoExecInstRules, _p_FIX__NoExecInstRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TimeBracket, _p_FIX__TimeBracketTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstMode, _p_FIX__SettlInstModeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplResponseError, _p_FIX__ApplResponseErrorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HaltReasonInt, _p_FIX__HaltReasonIntTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListNoOrds, _p_FIX__ListNoOrdsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSettlmntTyp, _p_FIX__LegSettlmntTypTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlmntTyp, _p_FIX__SettlmntTypTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdvRefID, _p_FIX__AdvRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BookingUnit, _p_FIX__BookingUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastPx, _p_FIX__LastPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegLastPx, _p_FIX__LegLastPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLastPx, _p_FIX__UnderlyingLastPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PrevClosePx, _p_FIX__PrevClosePxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDReportID, _p_FIX__MDReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityReportID, _p_FIX__SecurityReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTradeReportID, _p_FIX__SecondaryTradeReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplReportID, _p_FIX__ApplReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionReportID, _p_FIX__MassActionReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketReportID, _p_FIX__MarketReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegReportID, _p_FIX__LegReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportID, _p_FIX__TradeReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocReportID, _p_FIX__AllocReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTradeReportID, _p_FIX__SideTradeReportIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLegs, _p_FIX__NoLegsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CancellationRights, _p_FIX__CancellationRightsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityXML, _p_FIX__SecurityXMLTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXML, _p_FIX__DerivativeSecurityXMLTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMatchRules, _p_FIX__NoMatchRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RawData, _p_FIX__RawDataTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocHandlInst, _p_FIX__AllocHandlInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HandlInst, _p_FIX__HandlInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrdType, _p_FIX__OrdTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Factor, _p_FIX__FactorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingFactor, _p_FIX__UnderlyingFactorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegFactor, _p_FIX__LegFactorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MatchType, _p_FIX__MatchTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingIssueDate, _p_FIX__UnderlyingIssueDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeIssueDate, _p_FIX__DerivativeIssueDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IssueDate, _p_FIX__IssueDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegIssueDate, _p_FIX__LegIssueDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerType, _p_FIX__TriggerTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyingAmounts, _p_FIX__NoUnderlyingAmountsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidID, _p_FIX__BidIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlType, _p_FIX__SettlTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSettlType, _p_FIX__LegSettlTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityIndType, _p_FIX__LiquidityIndTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmType, _p_FIX__ConfirmTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAvgPx, _p_FIX__AllocAvgPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityReqID, _p_FIX__SecurityReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollApplType, _p_FIX__CollApplTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashMargin, _p_FIX__CashMarginTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgPx, _p_FIX__AvgPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingAllocationPercent, _p_FIX__UnderlyingAllocationPercentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderPercent, _p_FIX__OrderPercentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CrossPercent, _p_FIX__CrossPercentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesStartTime, _p_FIX__TradSesStartTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventStartTime, _p_FIX__ComplexEventStartTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedListExecInstLen, _p_FIX__EncodedListExecInstLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventTime, _p_FIX__EventTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventTime, _p_FIX__DerivativeEventTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyRole, _p_FIX__UndlyInstrumentPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartyRole, _p_FIX__RootPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRepPartyRole, _p_FIX__TrdRepPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartyRole, _p_FIX__InstrumentPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartyRole, _p_FIX__Nested4PartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartyRole, _p_FIX__NestedPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartyRole, _p_FIX__Nested3PartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyRole, _p_FIX__DerivativeInstrumentPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyRole, _p_FIX__PartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartyRole, _p_FIX__SettlPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartyRole, _p_FIX__Nested2PartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetPartyRole, _p_FIX__TargetPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyRole, _p_FIX__UnderlyingInstrumentPartyRoleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentCode, _p_FIX__CashSettlAgentCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentCode, _p_FIX__SecuritySettlAgentCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribAgentCode, _p_FIX__CashDistribAgentCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCreditRating, _p_FIX__LegCreditRatingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CreditRating, _p_FIX__CreditRatingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCreditRating, _p_FIX__UnderlyingCreditRatingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCashType, _p_FIX__UnderlyingCashTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmReqID, _p_FIX__ConfirmReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRpts, _p_FIX__NoRptsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoBidDescriptors, _p_FIX__NoBidDescriptorsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegDividendYield, _p_FIX__LegDividendYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DividendYield, _p_FIX__DividendYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetworkResponseID, _p_FIX__NetworkResponseIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityResponseID, _p_FIX__SecurityResponseIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastNetworkResponseID, _p_FIX__LastNetworkResponseIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplResponseID, _p_FIX__ApplResponseIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MultilegModel, _p_FIX__MultilegModelTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraTradeQty, _p_FIX__ContraTradeQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InViewOfCommon, _p_FIX__InViewOfCommonTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CrossPrioritization, _p_FIX__CrossPrioritizationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayLowQty, _p_FIX__DisplayLowQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RateSource, _p_FIX__RateSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListTypeSource, _p_FIX__SecurityListTypeSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligSource, _p_FIX__SettlObligSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeskTypeSource, _p_FIX__DeskTypeSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCoveredOrUncovered, _p_FIX__LegCoveredOrUncoveredTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CoveredOrUncovered, _p_FIX__CoveredOrUncoveredTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteReqID, _p_FIX__QuoteReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeFloorPrice, _p_FIX__DerivativeFloorPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerPrice, _p_FIX__TriggerPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FloorPrice, _p_FIX__FloorPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PutOrCall, _p_FIX__PutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPutOrCall, _p_FIX__LegPutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePutOrCall, _p_FIX__DerivativePutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegPutOrCall, _p_FIX__UnderlyingLegPutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPutOrCall, _p_FIX__UnderlyingPutOrCallTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentAcctNum, _p_FIX__CashSettlAgentAcctNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentAcctNum, _p_FIX__SecuritySettlAgentAcctNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StandInstDbName, _p_FIX__StandInstDbNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RiskFreeRate, _p_FIX__RiskFreeRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRespID, _p_FIX__QuoteRespIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldRedemptionPrice, _p_FIX__YieldRedemptionPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionPrice, _p_FIX__DiscretionPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CxlType, _p_FIX__CxlTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CPRegType, _p_FIX__CPRegTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCPRegType, _p_FIX__UnderlyingCPRegTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnRefID, _p_FIX__CollAsgnRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoExpiration, _p_FIX__NoExpirationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TimeToExpiration, _p_FIX__TimeToExpirationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OwnershipType, _p_FIX__OwnershipTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStipType, _p_FIX__UnderlyingStipTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceProtectionScope, _p_FIX__PriceProtectionScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionScope, _p_FIX__MassActionScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionScope, _p_FIX__DiscretionScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ResponseDestination, _p_FIX__ResponseDestinationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExDestination, _p_FIX__ExDestinationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Designation, _p_FIX__DesignationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesOpenTime, _p_FIX__TradSesOpenTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyingStips, _p_FIX__NoUnderlyingStipsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PeggedRefPrice, _p_FIX__PeggedRefPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOptionRatio, _p_FIX__LegOptionRatioTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarginRatio, _p_FIX__MarginRatioTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Urgency, _p_FIX__UrgencyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PaymentRef, _p_FIX__PaymentRefTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExchangeForPhysical, _p_FIX__ExchangeForPhysicalTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefOfferSize, _p_FIX__DefOfferSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferSize, _p_FIX__OfferSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinOfferSize, _p_FIX__MinOfferSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedMktSegmDesc, _p_FIX__EncodedMktSegmDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RFQReqID, _p_FIX__RFQReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideQty, _p_FIX__SideQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocSettlCurrAmt, _p_FIX__AllocSettlCurrAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrAmt, _p_FIX__SettlCurrAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__XmlData, _p_FIX__XmlDataTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NumTickets, _p_FIX__NumTicketsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOINaturalFlag, _p_FIX__IOINaturalFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventCondition, _p_FIX__ComplexEventConditionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeCondition, _p_FIX__TradeConditionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteCondition, _p_FIX__QuoteConditionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidYield, _p_FIX__BidYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MidYield, _p_FIX__MidYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetGrossInd, _p_FIX__NetGrossIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecValuationPoint, _p_FIX__ExecValuationPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AffectedOrderID, _p_FIX__AffectedOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderID, _p_FIX__OrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NotAffectedOrderID, _p_FIX__NotAffectedOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AffectedSecondaryOrderID, _p_FIX__AffectedSecondaryOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryOrderID, _p_FIX__SecondaryOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefOrderID, _p_FIX__RefOrderIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReferencePage, _p_FIX__ReferencePageTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartyIDSource, _p_FIX__SettlPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAcctIDSource, _p_FIX__AllocAcctIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityIDSource, _p_FIX__UnderlyingSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyIDSource, _p_FIX__PartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InputSource, _p_FIX__InputSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegSecurityIDSource, _p_FIX__PegSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerSecurityIDSource, _p_FIX__TriggerSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityAltIDSource, _p_FIX__LegSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartyIDSource, _p_FIX__NestedPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingIDSource, _p_FIX__UnderlyingIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityAltIDSource, _p_FIX__SecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityAltIDSource, _p_FIX__UnderlyingLegSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityIDSource, _p_FIX__SecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyIDSource, _p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyIDSource, _p_FIX__UnderlyingInstrumentPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAltMDSource, _p_FIX__NoAltMDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExDestinationIDSource, _p_FIX__ExDestinationIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderHandlingInstSource, _p_FIX__OrderHandlingInstSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkSecurityIDSource, _p_FIX__BenchmarkSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityIDSource, _p_FIX__DerivativeSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AcctIDSource, _p_FIX__AcctIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartyIDSource, _p_FIX__Nested4PartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartyIDSource, _p_FIX__RootPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityAltIDSource, _p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartyIDSource, _p_FIX__Nested3PartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IDSource, _p_FIX__IDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetPartyIDSource, _p_FIX__TargetPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartyIDSource, _p_FIX__InstrumentPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityIDSource, _p_FIX__LegSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstSource, _p_FIX__SettlInstSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeInputSource, _p_FIX__TradeInputSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyIDSource, _p_FIX__UndlyInstrumentPartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MessageEventSource, _p_FIX__MessageEventSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefOrderIDSource, _p_FIX__RefOrderIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartyIDSource, _p_FIX__Nested2PartyIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocAcctIDSource, _p_FIX__LegAllocAcctIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityAltIDSource, _p_FIX__UnderlyingSecurityAltIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityIDSource, _p_FIX__UnderlyingLegSecurityIDSourceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplTotalMessageCount, _p_FIX__ApplTotalMessageCountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FairValue, _p_FIX__FairValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrategyParameterValue, _p_FIX__StrategyParameterValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegalConfirm, _p_FIX__LegalConfirmTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContractSettlMonth, _p_FIX__ContractSettlMonthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegContractSettlMonth, _p_FIX__LegContractSettlMonthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeContractSettlMonth, _p_FIX__DerivativeContractSettlMonthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteID, _p_FIX__QuoteIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TransBkdTime, _p_FIX__TransBkdTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollRespID, _p_FIX__CollRespIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestampType, _p_FIX__SideTrdRegTimestampTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRegTimestampType, _p_FIX__TrdRegTimestampTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStipulationValue, _p_FIX__LegStipulationValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StipulationValue, _p_FIX__StipulationValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CharField, _p_FIX__CharFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MidPx, _p_FIX__MidPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesMode, _p_FIX__TradSesModeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Country, _p_FIX__CountryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryDate, _p_FIX__MDEntryDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Rule80A, _p_FIX__Rule80ATo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrumentParties, _p_FIX__NoDerivativeInstrumentPartiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUndlyInstrumentParties, _p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoInstrumentParties, _p_FIX__NoInstrumentPartiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LongQty, _p_FIX__LongQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSwapType, _p_FIX__LegSwapTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FillQty, _p_FIX__FillQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrAttribValue, _p_FIX__InstrAttribValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrAttribValue, _p_FIX__DerivativeInstrAttribValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedInstrAttribValue, _p_FIX__NestedInstrAttribValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoundingModulus, _p_FIX__RoundingModulusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocLinkType, _p_FIX__AllocLinkTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocReportType, _p_FIX__AllocReportTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportType, _p_FIX__TradeReportTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ResponseTransportType, _p_FIX__ResponseTransportTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplReportType, _p_FIX__ApplReportTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedPassword, _p_FIX__EncryptedPasswordTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Password, _p_FIX__PasswordTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedNewPassword, _p_FIX__EncryptedNewPasswordTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewPassword, _p_FIX__NewPasswordTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementType, _p_FIX__UnderlyingSettlementTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventType, _p_FIX__EventTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventType, _p_FIX__ComplexEventTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAccountType, _p_FIX__AllocAccountTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AccountType, _p_FIX__AccountTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdjustmentType, _p_FIX__AdjustmentTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventType, _p_FIX__DerivativeEventTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RespondentType, _p_FIX__RespondentTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FutSettDate2, _p_FIX__FutSettDate2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceDelta, _p_FIX__PriceDeltaTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideValue1, _p_FIX__SideValue1To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideValue2, _p_FIX__SideValue2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSymbol, _p_FIX__DerivativeSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSymbol, _p_FIX__LegSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSymbol, _p_FIX__UnderlyingSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSymbol, _p_FIX__UnderlyingLegSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegSymbol, _p_FIX__PegSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Symbol, _p_FIX__SymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderQty2, _p_FIX__OrderQty2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AltMDSourceID, _p_FIX__AltMDSourceIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoQuoteEntries, _p_FIX__TotNoQuoteEntriesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMDEntries, _p_FIX__NoMDEntriesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotQuoteEntries, _p_FIX__TotQuoteEntriesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoQuoteEntries, _p_FIX__NoQuoteEntriesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__VenueType, _p_FIX__VenueTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerNewQty, _p_FIX__TriggerNewQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TimeInForce, _p_FIX__TimeInForceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTimeInForce, _p_FIX__SideTimeInForceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstMsgID, _p_FIX__SettlInstMsgIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdvSide, _p_FIX__AdvSideTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlDate2, _p_FIX__SettlDate2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigOrdModTime, _p_FIX__OrigOrdModTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplQueueDepth, _p_FIX__ApplQueueDepthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FieldBase, 0, 0, 0},  {&_swigt__p_FIX__MatchAlgorithm, _p_FIX__MatchAlgorithmTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Signature, _p_FIX__SignatureTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Text, _p_FIX__TextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InterestAccrualDate, _p_FIX__InterestAccrualDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegInterestAccrualDate, _p_FIX__LegInterestAccrualDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Pool, _p_FIX__PoolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SendingDate, _p_FIX__SendingDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistID, _p_FIX__RegistIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewSeqNo, _p_FIX__NewSeqNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegInstrRegistry, _p_FIX__LegInstrRegistryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrRegistry, _p_FIX__InstrRegistryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrRegistry, _p_FIX__DerivativeInstrRegistryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrRegistry, _p_FIX__UnderlyingInstrRegistryTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMaturityRules, _p_FIX__NoMaturityRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MiscFeeType, _p_FIX__MiscFeeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliveryDate, _p_FIX__DeliveryDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ValidUntilTime, _p_FIX__ValidUntilTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteSetValidUntilTime, _p_FIX__QuoteSetValidUntilTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClientBidID, _p_FIX__ClientBidIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSecurityListDesc, _p_FIX__EncodedSecurityListDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListDesc, _p_FIX__SecurityListDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ParentMktSegmID, _p_FIX__ParentMktSegmIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StatsType, _p_FIX__StatsTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoComplexEventDates, _p_FIX__NoComplexEventDatesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityPctHigh, _p_FIX__LiquidityPctHighTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideReasonCd, _p_FIX__SideReasonCdTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerSymbol, _p_FIX__TriggerSymbolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSides, _p_FIX__NoSidesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryTime, _p_FIX__MDEntryTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReportToExch, _p_FIX__ReportToExchTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSubject, _p_FIX__EncodedSubjectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Subject, _p_FIX__SubjectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocLinkID, _p_FIX__AllocLinkIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeLinkID, _p_FIX__TradeLinkIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBidPx, _p_FIX__LegBidPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLotTypeRules, _p_FIX__NoLotTypeRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOrdTypeRules, _p_FIX__NoOrdTypeRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplQueueMax, _p_FIX__ApplQueueMaxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FundRenewWaiv, _p_FIX__FundRenewWaivTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Adjustment, _p_FIX__AdjustmentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecPriceAdjustment, _p_FIX__ExecPriceAdjustmentTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetSubID, _p_FIX__TargetSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceTimeType, _p_FIX__ComplexEventPriceTimeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOfferPx, _p_FIX__LegOfferPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MktOfferPx, _p_FIX__MktOfferPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferPx, _p_FIX__OfferPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPool, _p_FIX__LegPoolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMDFeedTypes, _p_FIX__NoMDFeedTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidPx, _p_FIX__BidPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastSpotRate, _p_FIX__LastSpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferSpotRate, _p_FIX__OfferSpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidSpotRate, _p_FIX__BidSpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntrySpotRate, _p_FIX__MDEntrySpotRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXMLSchema, _p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityXMLSchema, _p_FIX__SecurityXMLSchemaTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstCode, _p_FIX__SettlInstCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OpenInterest, _p_FIX__OpenInterestTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NumDaysInterest, _p_FIX__NumDaysInterestTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideValueInd, _p_FIX__SideValueIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityMonthYear, _p_FIX__UnderlyingLegMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndMaturityMonthYear, _p_FIX__EndMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityMonthYear, _p_FIX__UnderlyingMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityMonthYear, _p_FIX__DerivativeMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityMonthYear, _p_FIX__MaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartMaturityMonthYear, _p_FIX__StartMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegMaturityMonthYear, _p_FIX__LegMaturityMonthYearTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoIOIQualifiers, _p_FIX__NoIOIQualifiersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoQuoteQualifiers, _p_FIX__NoQuoteQualifiersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDOriginType, _p_FIX__MDOriginTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderQty, _p_FIX__OrderQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOrderQty, _p_FIX__LegOrderQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashOrderQty, _p_FIX__CashOrderQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DayOrderQty, _p_FIX__DayOrderQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeInputDevice, _p_FIX__TradeInputDeviceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderInputDevice, _p_FIX__OrderInputDeviceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoutingID, _p_FIX__RoutingIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlOblig, _p_FIX__NoSettlObligTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyingLegSecurityAltID, _p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityAltID, _p_FIX__UnderlyingSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUnderlyingSecurityAltID, _p_FIX__NoUnderlyingSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityAltID, _p_FIX__LegSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLegSecurityAltID, _p_FIX__NoLegSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityAltID, _p_FIX__SecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSecurityAltID, _p_FIX__NoSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityAltID, _p_FIX__UnderlyingLegSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeSecurityAltID, _p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityAltID, _p_FIX__DerivativeSecurityAltIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SendingTime, _p_FIX__SendingTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OnBehalfOfSendingTime, _p_FIX__OnBehalfOfSendingTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigSendingTime, _p_FIX__OrigSendingTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HopSendingTime, _p_FIX__HopSendingTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListExecInst, _p_FIX__ListExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegExecInst, _p_FIX__LegExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedListExecInst, _p_FIX__EncodedListExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecInst, _p_FIX__ExecInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LinesOfText, _p_FIX__LinesOfTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLinesOfText, _p_FIX__NoLinesOfTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlDepositoryCode, _p_FIX__SettlDepositoryCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradedFlatSwitch, _p_FIX__TradedFlatSwitchTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClOrdLinkID, _p_FIX__ClOrdLinkIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTimeInForceRules, _p_FIX__NoTimeInForceRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStrikeRules, _p_FIX__NoStrikeRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkPrice, _p_FIX__BenchmarkPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkPrice, _p_FIX__LegBenchmarkPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DueToRelated, _p_FIX__DueToRelatedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDlvyInst, _p_FIX__NoDlvyInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DlvyInst, _p_FIX__DlvyInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AccruedInterestRate, _p_FIX__AccruedInterestRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecureData, _p_FIX__SecureDataTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MessageEncoding, _p_FIX__MessageEncodingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpireDate, _p_FIX__ExpireDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BasisFeatureDate, _p_FIX__BasisFeatureDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayWhen, _p_FIX__DisplayWhenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StartTickPriceRange, _p_FIX__StartTickPriceRangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndTickPriceRange, _p_FIX__EndTickPriceRangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoCompIDs, _p_FIX__NoCompIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BookingRefID, _p_FIX__BookingRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__WtAverageLiquidity, _p_FIX__WtAverageLiquidityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceImprovement, _p_FIX__PriceImprovementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTrdSubTyp, _p_FIX__SideTrdSubTypTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TickIncrement, _p_FIX__TickIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearIncrement, _p_FIX__MaturityMonthYearIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MatchIncrement, _p_FIX__MatchIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeIncrement, _p_FIX__StrikeIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMinPriceIncrement, _p_FIX__DerivativeMinPriceIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinPriceIncrement, _p_FIX__MinPriceIncrementTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecType, _p_FIX__ExecTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MailingDtls, _p_FIX__MailingDtlsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HaltReasonChar, _p_FIX__HaltReasonCharTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ModelType, _p_FIX__ModelTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEventText, _p_FIX__DerivativeEventTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EventText, _p_FIX__EventTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IndividualAllocRejCode, _p_FIX__IndividualAllocRejCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocRejCode, _p_FIX__AllocRejCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstReqRejCode, _p_FIX__SettlInstReqRejCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerNewPrice, _p_FIX__TriggerNewPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingFirm, _p_FIX__ClearingFirmTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlementCycleNo, _p_FIX__SettlementCycleNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelSymTransactTime, _p_FIX__RelSymTransactTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TZTransactTime, _p_FIX__TZTransactTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TransactTime, _p_FIX__TransactTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty, _p_FIX__UnderlyingPriceUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceUnitOfMeasureQty, _p_FIX__PriceUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePriceUnitOfMeasureQty, _p_FIX__DerivativePriceUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeUnitOfMeasureQty, _p_FIX__DerivativeUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnitOfMeasureQty, _p_FIX__UnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingUnitOfMeasureQty, _p_FIX__UnderlyingUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPriceUnitOfMeasureQty, _p_FIX__LegPriceUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegUnitOfMeasureQty, _p_FIX__LegUnitOfMeasureQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewsRefID, _p_FIX__NewsRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryType, _p_FIX__MDEntryTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgParPx, _p_FIX__AvgParPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIQltyInd, _p_FIX__IOIQltyIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAllocs, _p_FIX__NoAllocsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoAllocs, _p_FIX__TotNoAllocsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoLegAllocs, _p_FIX__NoLegAllocsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistDtls, _p_FIX__RegistDtlsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRegistDtls, _p_FIX__NoRegistDtlsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeskOrderHandlingInst, _p_FIX__DeskOrderHandlingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__GTBookingInst, _p_FIX__GTBookingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CustOrderHandlingInst, _p_FIX__CustOrderHandlingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MailingInst, _p_FIX__MailingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DayBookingInst, _p_FIX__DayBookingInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPrice, _p_FIX__LegPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplVerID, _p_FIX__RefApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CstmApplVerID, _p_FIX__CstmApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefaultApplVerID, _p_FIX__DefaultApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefCstmApplVerID, _p_FIX__RefCstmApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplVerID, _p_FIX__ApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefaultCstmApplVerID, _p_FIX__DefaultCstmApplVerIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DateOfBirth, _p_FIX__DateOfBirthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastMsgSeqNumProcessed, _p_FIX__LastMsgSeqNumProcessedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligRefID, _p_FIX__SettlObligRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRefID, _p_FIX__LegRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraLegRefID, _p_FIX__ContraLegRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeLegRefID, _p_FIX__TradeLegRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRateSources, _p_FIX__NoRateSourcesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NotionalPercentageOutstanding, _p_FIX__NotionalPercentageOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashOutstanding, _p_FIX__CashOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingNotionalPercentageOutstanding, _p_FIX__UnderlyingNotionalPercentageOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OriginalNotionalPercentageOutstanding, _p_FIX__OriginalNotionalPercentageOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdMatchID, _p_FIX__TrdMatchIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliverToCompID, _p_FIX__DeliverToCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocPrice, _p_FIX__AllocPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StringField, _p_FIX__StringFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocSettlInstType, _p_FIX__AllocSettlInstTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListExecInstType, _p_FIX__ListExecInstTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DlvyInstType, _p_FIX__DlvyInstTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingSessionID, _p_FIX__TradingSessionIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerTradingSessionID, _p_FIX__TriggerTradingSessionIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingTradingSessionID, _p_FIX__UnderlyingTradingSessionIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegScope, _p_FIX__PegScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoAccQuotes, _p_FIX__TotNoAccQuotesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollInquiryID, _p_FIX__CollInquiryIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecRefID, _p_FIX__ExecRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CxlRejResponseTo, _p_FIX__CxlRejResponseToTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Price, _p_FIX__PriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LotType, _p_FIX__LotTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestampSrc, _p_FIX__SideTrdRegTimestampSrcTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EmailType, _p_FIX__EmailTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeOptAttribute, _p_FIX__DerivativeOptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegOptAttribute, _p_FIX__UnderlyingLegOptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OptAttribute, _p_FIX__OptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingOptAttribute, _p_FIX__UnderlyingOptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOptAttribute, _p_FIX__LegOptAttributeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlLocation, _p_FIX__SettlLocationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EffectiveTime, _p_FIX__EffectiveTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnReqID, _p_FIX__StreamAsgnReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteCancelType, _p_FIX__QuoteCancelTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Scope, _p_FIX__ScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpireTime, _p_FIX__ExpireTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlBrkrCode, _p_FIX__SettlBrkrCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PreTradeAnonymity, _p_FIX__PreTradeAnonymityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoutingType, _p_FIX__RoutingTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideMultiLegReportingType, _p_FIX__SideMultiLegReportingTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BookingType, _p_FIX__BookingTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRestructuringType, _p_FIX__UnderlyingRestructuringTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RestructuringType, _p_FIX__RestructuringTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MultiLegReportingType, _p_FIX__MultiLegReportingTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StatusValue, _p_FIX__StatusValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessValue, _p_FIX__AllowableOneSidednessValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTrdRegTimestamps, _p_FIX__NoTrdRegTimestampsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListID, _p_FIX__ListIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListID, _p_FIX__SecurityListIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliveryType, _p_FIX__DeliveryTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlDeliveryType, _p_FIX__SettlDeliveryTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PrivateQuote, _p_FIX__PrivateQuoteTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedHeadlineLen, _p_FIX__EncodedHeadlineLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BasisPxType, _p_FIX__BasisPxTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityRuleID, _p_FIX__MaturityRuleIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeRuleID, _p_FIX__StrikeRuleIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteMsgID, _p_FIX__QuoteMsgIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeskType, _p_FIX__DeskTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrategyParameterName, _p_FIX__StrategyParameterNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardHolderName, _p_FIX__CardHolderNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RptSys, _p_FIX__RptSysTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegQty, _p_FIX__LegQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoSecurityTypes, _p_FIX__TotNoSecurityTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMDEntryTypes, _p_FIX__NoMDEntryTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalNumSecurityTypes, _p_FIX__TotalNumSecurityTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSecurityTypes, _p_FIX__NoSecurityTypesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxPriceLevels, _p_FIX__MaxPriceLevelsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefCompID, _p_FIX__RefCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SenderCompID, _p_FIX__SenderCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetCompID, _p_FIX__TargetCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HopCompID, _p_FIX__HopCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OnBehalfOfCompID, _p_FIX__OnBehalfOfCompIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListStatusType, _p_FIX__ListStatusTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDBookType, _p_FIX__MDBookTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDSubBookType, _p_FIX__MDSubBookTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityRequestType, _p_FIX__SecurityRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListRequestType, _p_FIX__SecurityListRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRequestType, _p_FIX__QuoteRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListType, _p_FIX__SecurityListTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeRequestType, _p_FIX__TradeRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UserRequestType, _p_FIX__UserRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetworkRequestType, _p_FIX__NetworkRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SubscriptionRequestType, _p_FIX__SubscriptionRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassCancelRequestType, _p_FIX__MassCancelRequestTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedIssuerLen, _p_FIX__EncodedIssuerLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedLegIssuerLen, _p_FIX__EncodedLegIssuerLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedIssuerLen, _p_FIX__DerivativeEncodedIssuerLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingIssuerLen, _p_FIX__EncodedUnderlyingIssuerLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoRejQuotes, _p_FIX__TotNoRejQuotesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoCxldQuotes, _p_FIX__TotNoCxldQuotesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeProductComplex, _p_FIX__DerivativeProductComplexTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ProductComplex, _p_FIX__ProductComplexTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CustOrderCapacity, _p_FIX__CustOrderCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigCustOrderCapacity, _p_FIX__OrigCustOrderCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocCustomerCapacity, _p_FIX__AllocCustomerCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastCapacity, _p_FIX__LastCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DealingCapacity, _p_FIX__DealingCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderCapacity, _p_FIX__OrderCapacityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityNumSecurities, _p_FIX__LiquidityNumSecuritiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalNumSecurities, _p_FIX__TotalNumSecuritiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistEmail, _p_FIX__RegistEmailTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideComplianceID, _p_FIX__SideComplianceIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplianceID, _p_FIX__ComplianceIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndSeqNo, _p_FIX__EndSeqNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartySubID, _p_FIX__UndlyInstrumentPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartySubID, _p_FIX__DerivativeInstrumentPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartySubID, _p_FIX__Nested3PartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartySubID, _p_FIX__Nested4PartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartySubID, _p_FIX__UnderlyingInstrumentPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartySubID, _p_FIX__SettlPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartySubID, _p_FIX__PartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartySubID, _p_FIX__RootPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartySubID, _p_FIX__InstrumentPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartySubID, _p_FIX__NestedPartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartySubID, _p_FIX__Nested2PartySubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnAckType, _p_FIX__StreamAsgnAckTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRegTimestampOrigin, _p_FIX__TrdRegTimestampOriginTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribPayRef, _p_FIX__CashDistribPayRefTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistAcctType, _p_FIX__RegistAcctTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DistribPercentage, _p_FIX__DistribPercentageTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMarketSegments, _p_FIX__NoMarketSegmentsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIOthSvc, _p_FIX__IOIOthSvcTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExchangeRule, _p_FIX__ExchangeRuleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReceivedDeptID, _p_FIX__ReceivedDeptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefTagID, _p_FIX__RefTagIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ProgRptReqs, _p_FIX__ProgRptReqsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CcyAmt, _p_FIX__CcyAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListSeqNo, _p_FIX__ListSeqNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LowPx, _p_FIX__LowPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CustDirectedOrder, _p_FIX__CustDirectedOrderTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDStreamID, _p_FIX__MDStreamIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntrySize, _p_FIX__MDEntrySizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetStrategyPerformance, _p_FIX__TargetStrategyPerformanceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoHops, _p_FIX__NoHopsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EFPTrackingError, _p_FIX__EFPTrackingErrorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MktBidPx, _p_FIX__MktBidPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AsgnRptID, _p_FIX__AsgnRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnRptID, _p_FIX__StreamAsgnRptIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxFloor, _p_FIX__MaxFloorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocInterestAtMaturity, _p_FIX__AllocInterestAtMaturityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InterestAtMaturity, _p_FIX__InterestAtMaturityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideExecID, _p_FIX__SideExecIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecID, _p_FIX__ExecIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryExecID, _p_FIX__SecondaryExecIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Spread, _p_FIX__SpreadTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDSecSizeType, _p_FIX__MDSecSizeTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CustomerOrFirm, _p_FIX__CustomerOrFirmTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDescLen, _p_FIX__EncodedSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSecurityListDescLen, _p_FIX__EncodedSecurityListDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingSecurityDescLen, _p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedSecurityDescLen, _p_FIX__DerivativeEncodedSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedMktSegmDescLen, _p_FIX__EncodedMktSegmDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedLegSecurityDescLen, _p_FIX__EncodedLegSecurityDescLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryOriginator, _p_FIX__MDEntryOriginatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FutSettDate, _p_FIX__FutSettDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegFutSettDate, _p_FIX__LegFutSettDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidDescriptorType, _p_FIX__BidDescriptorTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoMiscFees, _p_FIX__NoMiscFeesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExDate, _p_FIX__ExDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegMoveType, _p_FIX__PegMoveTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionMoveType, _p_FIX__DiscretionMoveTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Price2, _p_FIX__Price2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClientID, _p_FIX__ClientIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RawDataLength, _p_FIX__RawDataLengthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BodyLength, _p_FIX__BodyLengthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SignatureLength, _p_FIX__SignatureLengthTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoClearingInstructions, _p_FIX__NoClearingInstructionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderRestrictions, _p_FIX__OrderRestrictionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExchangeSpecialInstructions, _p_FIX__ExchangeSpecialInstructionsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntrySeller, _p_FIX__MDEntrySellerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDSecSize, _p_FIX__MDSecSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinLotSize, _p_FIX__MinLotSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityDay, _p_FIX__UnderlyingMaturityDayTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityDay, _p_FIX__MaturityDayTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionResponse, _p_FIX__MassActionResponseTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassCancelResponse, _p_FIX__MassCancelResponseTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideFillStationCd, _p_FIX__SideFillStationCdTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocShares, _p_FIX__AllocSharesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Shares, _p_FIX__SharesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIShares, _p_FIX__IOISharesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyID, _p_FIX__UndlyInstrumentPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetPartyID, _p_FIX__TargetPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartyID, _p_FIX__NestedPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartyID, _p_FIX__Nested3PartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyID, _p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartyID, _p_FIX__SettlPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartyID, _p_FIX__Nested4PartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartyID, _p_FIX__PartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartyID, _p_FIX__RootPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyID, _p_FIX__DerivativeInstrumentPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartyID, _p_FIX__InstrumentPartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartyID, _p_FIX__Nested2PartyIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplQueueResolution, _p_FIX__ApplQueueResolutionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DayAvgPx, _p_FIX__DayAvgPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityXMLLen, _p_FIX__SecurityXMLLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXMLLen, _p_FIX__DerivativeSecurityXMLLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRoutingIDs, _p_FIX__NoRoutingIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryID, _p_FIX__MDEntryIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteEntryID, _p_FIX__QuoteEntryIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FillExecID, _p_FIX__FillExecIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InvestorCountryOfResidence, _p_FIX__InvestorCountryOfResidenceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriorSpreadIndicator, _p_FIX__PriorSpreadIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefreshIndicator, _p_FIX__RefreshIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefaultVerIndicator, _p_FIX__DefaultVerIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeAllocIndicator, _p_FIX__TradeAllocIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRepIndicator, _p_FIX__TrdRepIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PublishTrdIndicator, _p_FIX__PublishTrdIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradePublishIndicator, _p_FIX__TradePublishIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CopyMsgIndicator, _p_FIX__CopyMsgIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ImpliedMarketIndicator, _p_FIX__ImpliedMarketIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnsolicitedIndicator, _p_FIX__UnsolicitedIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LateIndicator, _p_FIX__LateIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FlexibleIndicator, _p_FIX__FlexibleIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AutoAcceptIndicator, _p_FIX__AutoAcceptIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivFlexProductEligibilityIndicator, _p_FIX__DerivFlexProductEligibilityIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgPxIndicator, _p_FIX__AvgPxIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TestMessageIndicator, _p_FIX__TestMessageIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__WorkingIndicator, _p_FIX__WorkingIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ManualOrderIndicator, _p_FIX__ManualOrderIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraryInstructionIndicator, _p_FIX__ContraryInstructionIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ReversalIndicator, _p_FIX__ReversalIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriorityIndicator, _p_FIX__PriorityIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FlexProductEligibilityIndicator, _p_FIX__FlexProductEligibilityIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AggressorIndicator, _p_FIX__AggressorIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocClearingFeeIndicator, _p_FIX__AllocClearingFeeIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingFeeIndicator, _p_FIX__ClearingFeeIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AsOfIndicator, _p_FIX__AsOfIndicatorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTradingSessionRules, _p_FIX__NoTradingSessionRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplID, _p_FIX__ApplIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AgreementID, _p_FIX__AgreementIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketSegmentID, _p_FIX__MarketSegmentIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventPrice, _p_FIX__ComplexEventPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraBroker, _p_FIX__ContraBrokerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecBroker, _p_FIX__ExecBrokerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingFXRateCalc, _p_FIX__UnderlyingFXRateCalcTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrFxRateCalc, _p_FIX__SettlCurrFxRateCalcTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTradeReportRefID, _p_FIX__SecondaryTradeReportRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintRptRefID, _p_FIX__PosMaintRptRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocReportRefID, _p_FIX__AllocReportRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportRefID, _p_FIX__TradeReportRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpirationCycle, _p_FIX__ExpirationCycleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ResetSeqNumFlag, _p_FIX__ResetSeqNumFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriorSettlPrice, _p_FIX__PriorSettlPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlPrice, _p_FIX__UnderlyingSettlPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPrice, _p_FIX__SettlPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideLiquidityInd, _p_FIX__SideLiquidityIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastLiquidityInd, _p_FIX__LastLiquidityIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FillLiquidityInd, _p_FIX__FillLiquidityIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegIssuer, _p_FIX__LegIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingIssuer, _p_FIX__EncodedUnderlyingIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeIssuer, _p_FIX__DerivativeIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingIssuer, _p_FIX__UnderlyingIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedLegIssuer, _p_FIX__EncodedLegIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Issuer, _p_FIX__IssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingSessionDesc, _p_FIX__TradingSessionDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnReqType, _p_FIX__StreamAsgnReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocIntermedReqType, _p_FIX__AllocIntermedReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosReqType, _p_FIX__PosReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassStatusReqType, _p_FIX__MassStatusReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplReqType, _p_FIX__ApplReqTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastShares, _p_FIX__LastSharesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FillPx, _p_FIX__FillPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingFXRate, _p_FIX__UnderlyingFXRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityExchange, _p_FIX__DerivativeSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityExchange, _p_FIX__UnderlyingLegSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityExchange, _p_FIX__SecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityExchange, _p_FIX__LegSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityExchange, _p_FIX__UnderlyingSecurityExchangeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldType, _p_FIX__YieldTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardIssNo, _p_FIX__CardIssNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingEndPrice, _p_FIX__UnderlyingEndPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocQty, _p_FIX__AllocQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocQty, _p_FIX__LegAllocQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmID, _p_FIX__ConfirmIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PartySubIDType, _p_FIX__PartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrumentPartySubIDType, _p_FIX__InstrumentPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RootPartySubIDType, _p_FIX__RootPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartySubIDType, _p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested2PartySubIDType, _p_FIX__Nested2PartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartySubIDType, _p_FIX__UndlyInstrumentPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartySubIDType, _p_FIX__UnderlyingInstrumentPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPartySubIDType, _p_FIX__SettlPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested3PartySubIDType, _p_FIX__Nested3PartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedPartySubIDType, _p_FIX__NestedPartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Nested4PartySubIDType, _p_FIX__Nested4PartySubIDTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SolicitedFlag, _p_FIX__SolicitedFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MiscFeeAmt, _p_FIX__MiscFeeAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RedemptionDate, _p_FIX__RedemptionDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeOriginationDate, _p_FIX__TradeOriginationDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRedemptionDate, _p_FIX__LegRedemptionDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRedemptionDate, _p_FIX__UnderlyingRedemptionDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldRedemptionDate, _p_FIX__YieldRedemptionDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedListStatusText, _p_FIX__EncodedListStatusTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListStatusText, _p_FIX__ListStatusTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StatusText, _p_FIX__StatusTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UserStatusText, _p_FIX__UserStatusTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OutsideIndexPct, _p_FIX__OutsideIndexPctTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPosAmt, _p_FIX__NoPosAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosAmt, _p_FIX__PosAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Headline, _p_FIX__HeadlineTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedHeadline, _p_FIX__EncodedHeadlineTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AttachmentPoint, _p_FIX__AttachmentPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DetachmentPoint, _p_FIX__DetachmentPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingAttachmentPoint, _p_FIX__UnderlyingAttachmentPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingDetachmentPoint, _p_FIX__UnderlyingDetachmentPointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalVolumeTradedDate, _p_FIX__TotalVolumeTradedDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegDatedDate, _p_FIX__LegDatedDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DatedDate, _p_FIX__DatedDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIQty, _p_FIX__IOIQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegIOIQty, _p_FIX__LegIOIQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastRptRequested, _p_FIX__LastRptRequestedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCouponRate, _p_FIX__UnderlyingCouponRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CouponRate, _p_FIX__CouponRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCouponRate, _p_FIX__LegCouponRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplID, _p_FIX__RefApplIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSideTrdRegTS, _p_FIX__NoSideTrdRegTSTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LowLimitPrice, _p_FIX__LowLimitPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryLowLimitPrice, _p_FIX__SecondaryLowLimitPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HighLimitPrice, _p_FIX__HighLimitPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryHighLimitPrice, _p_FIX__SecondaryHighLimitPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStartValue, _p_FIX__UnderlyingStartValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCurrentValue, _p_FIX__UnderlyingCurrentValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoApplIDs, _p_FIX__NoApplIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentName, _p_FIX__SecuritySettlAgentNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribAgentName, _p_FIX__CashDistribAgentNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentName, _p_FIX__CashSettlAgentNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistRefID, _p_FIX__RegistRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BusinessRejectRefID, _p_FIX__BusinessRejectRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstRefID, _p_FIX__SettlInstRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityListRefID, _p_FIX__SecurityListRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeCapPrice, _p_FIX__DerivativeCapPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CapPrice, _p_FIX__CapPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IntField, _p_FIX__IntFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentContactPhone, _p_FIX__CashSettlAgentContactPhoneTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentContactPhone, _p_FIX__SecuritySettlAgentContactPhoneTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RejectText, _p_FIX__RejectTextTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoundLot, _p_FIX__RoundLotTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HopRefID, _p_FIX__HopRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingExerciseStyle, _p_FIX__UnderlyingExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegExerciseStyle, _p_FIX__LegExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeExerciseStyle, _p_FIX__StrikeExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExerciseStyle, _p_FIX__ExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeExerciseStyle, _p_FIX__DerivativeExerciseStyleTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStrikes, _p_FIX__NoStrikesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoStrikes, _p_FIX__TotNoStrikesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAsgnReqs, _p_FIX__NoAsgnReqsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedIssuer, _p_FIX__DerivativeEncodedIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedIssuer, _p_FIX__EncodedIssuerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OddLot, _p_FIX__OddLotTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CheckSum, _p_FIX__CheckSumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferYield, _p_FIX__OfferYieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PeggedPrice, _p_FIX__PeggedPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingEndValue, _p_FIX__UnderlyingEndValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliverToLocationID, _p_FIX__DeliverToLocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OnBehalfOfLocationID, _p_FIX__OnBehalfOfLocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetLocationID, _p_FIX__TargetLocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LocationID, _p_FIX__LocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SenderLocationID, _p_FIX__SenderLocationIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__URLLink, _p_FIX__URLLinkTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribCurr, _p_FIX__CashDistribCurrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContingencyType, _p_FIX__ContingencyTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityStatusReqID, _p_FIX__SecurityStatusReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosReqID, _p_FIX__PosReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesReqID, _p_FIX__TradSesReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassStatusReqID, _p_FIX__MassStatusReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteStatusReqID, _p_FIX__QuoteStatusReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrdStatusReqID, _p_FIX__OrdStatusReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ProgPeriodInterval, _p_FIX__ProgPeriodIntervalTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalTakedown, _p_FIX__TotalTakedownTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRepurchaseRate, _p_FIX__LegRepurchaseRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RepurchaseRate, _p_FIX__RepurchaseRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRepurchaseRate, _p_FIX__UnderlyingRepurchaseRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastParPx, _p_FIX__LastParPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BeginString, _p_FIX__BeginStringTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDistribInsts, _p_FIX__NoDistribInstsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityPctLow, _p_FIX__LiquidityPctLowTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardIssNum, _p_FIX__CardIssNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefMsgType, _p_FIX__RefMsgTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MsgType, _p_FIX__MsgTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoFills, _p_FIX__TotNoFillsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoFills, _p_FIX__NoFillsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesCloseTime, _p_FIX__TradSesCloseTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesPreCloseTime, _p_FIX__TradSesPreCloseTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayHighQty, _p_FIX__DisplayHighQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidDescriptor, _p_FIX__BidDescriptorTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnRespType, _p_FIX__CollAsgnRespTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteRespType, _p_FIX__QuoteRespTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ParticipationRate, _p_FIX__ParticipationRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeVolume, _p_FIX__TradeVolumeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BuyVolume, _p_FIX__BuyVolumeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecInstValue, _p_FIX__ExecInstValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegOffsetValue, _p_FIX__PegOffsetValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContAmtValue, _p_FIX__ContAmtValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionOffsetValue, _p_FIX__DiscretionOffsetValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalNetValue, _p_FIX__TotalNetValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIid, _p_FIX__IOIidTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeTime, _p_FIX__StrikeTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HeartBtInt, _p_FIX__HeartBtIntTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStipValue, _p_FIX__UnderlyingStipValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCapValue, _p_FIX__UnderlyingCapValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedNewPasswordLen, _p_FIX__EncryptedNewPasswordLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedPasswordLen, _p_FIX__EncryptedPasswordLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeMultiplier, _p_FIX__DerivativeStrikeMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeContractMultiplier, _p_FIX__DerivativeContractMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikeMultiplier, _p_FIX__StrikeMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingContractMultiplier, _p_FIX__UnderlyingContractMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegContractMultiplier, _p_FIX__LegContractMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContractMultiplier, _p_FIX__ContractMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FeeMultiplier, _p_FIX__FeeMultiplierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistRejReasonCode, _p_FIX__RegistRejReasonCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ForexReq, _p_FIX__ForexReqTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Side, _p_FIX__SideTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDMkt, _p_FIX__MDMktTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlSessID, _p_FIX__SettlSessIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UtcTimeStampField, _p_FIX__UtcTimeStampFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LanguageCode, _p_FIX__LanguageCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSubjectLen, _p_FIX__EncodedSubjectLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewsRefType, _p_FIX__NewsRefTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalVolumeTradedTime, _p_FIX__TotalVolumeTradedTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__WaveNo, _p_FIX__WaveNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalVolumeTraded, _p_FIX__TotalVolumeTradedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoContraBrokers, _p_FIX__NoContraBrokersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OutMainCntryUIndex, _p_FIX__OutMainCntryUIndexTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HighPx, _p_FIX__HighPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BoolField, _p_FIX__BoolFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPx, _p_FIX__UnderlyingPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NewsID, _p_FIX__NewsIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContraTrader, _p_FIX__ContraTraderTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTrades, _p_FIX__NoTradesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessPct, _p_FIX__AllowableOneSidednessPctTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplBegSeqNum, _p_FIX__ApplBegSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MsgSeqNum, _p_FIX__MsgSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplNewSeqNum, _p_FIX__ApplNewSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NextExpectedMsgSeqNum, _p_FIX__NextExpectedMsgSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Volatility, _p_FIX__VolatilityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegVolatility, _p_FIX__LegVolatilityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNewsRefIDs, _p_FIX__NoNewsRefIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContAmtCurr, _p_FIX__ContAmtCurrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StandInstDbType, _p_FIX__StandInstDbTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingInstruction, _p_FIX__ClearingInstructionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastMkt, _p_FIX__LastMktTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityResponseType, _p_FIX__SecurityResponseTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplResponseType, _p_FIX__ApplResponseTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetworkStatusResponseType, _p_FIX__NetworkStatusResponseTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryAllocID, _p_FIX__SecondaryAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IndividualAllocID, _p_FIX__IndividualAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefAllocID, _p_FIX__RefAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryIndividualAllocID, _p_FIX__SecondaryIndividualAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegAllocID, _p_FIX__LegAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegIndividualAllocID, _p_FIX__LegIndividualAllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocID, _p_FIX__AllocIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EmailThreadID, _p_FIX__EmailThreadIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SellVolume, _p_FIX__SellVolumeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedSecurityDesc, _p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityDesc, _p_FIX__DerivativeSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerSecurityDesc, _p_FIX__TriggerSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegSecurityDesc, _p_FIX__PegSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityDesc, _p_FIX__UnderlyingLegSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityDesc, _p_FIX__UnderlyingSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityDesc, _p_FIX__SecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingSecurityDesc, _p_FIX__EncodedUnderlyingSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedLegSecurityDesc, _p_FIX__EncodedLegSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDesc, _p_FIX__EncodedSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityDesc, _p_FIX__LegSecurityDescTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoComplexEventTimes, _p_FIX__NoComplexEventTimesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CardExpDate, _p_FIX__CardExpDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndAccruedInterestAmt, _p_FIX__EndAccruedInterestAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalAccruedInterestAmt, _p_FIX__TotalAccruedInterestAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AccruedInterestAmt, _p_FIX__AccruedInterestAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocAccruedInterestAmt, _p_FIX__AllocAccruedInterestAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingContractMultiplierUnit, _p_FIX__UnderlyingContractMultiplierUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeContractMultiplierUnit, _p_FIX__DerivativeContractMultiplierUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegContractMultiplierUnit, _p_FIX__LegContractMultiplierUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ContractMultiplierUnit, _p_FIX__ContractMultiplierUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSide, _p_FIX__LegSideTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoStrategyParameters, _p_FIX__NoStrategyParametersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetStrategyParameters, _p_FIX__TargetStrategyParametersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoCapacities, _p_FIX__NoCapacitiesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityDate, _p_FIX__UnderlyingMaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegMaturityDate, _p_FIX__LegMaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityDate, _p_FIX__MaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuantityDate, _p_FIX__QuantityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityDate, _p_FIX__UnderlyingLegMaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityDate, _p_FIX__DerivativeMaturityDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionRoundDirection, _p_FIX__DiscretionRoundDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MsgDirection, _p_FIX__MsgDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TickDirection, _p_FIX__TickDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerPriceDirection, _p_FIX__TriggerPriceDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RoundingDirection, _p_FIX__RoundingDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegRoundDirection, _p_FIX__PegRoundDirectionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PossResend, _p_FIX__PossResendTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RateSourceType, _p_FIX__RateSourceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityGroup, _p_FIX__DerivativeSecurityGroupTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityGroup, _p_FIX__SecurityGroupTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoOrders, _p_FIX__TotNoOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOrders, _p_FIX__NoOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosReqResult, _p_FIX__PosReqResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollInquiryResult, _p_FIX__CollInquiryResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegDifference, _p_FIX__PegDifferenceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CorporateAction, _p_FIX__CorporateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesUpdateAction, _p_FIX__TradSesUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityUpdateAction, _p_FIX__SecurityUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListUpdateAction, _p_FIX__ListUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketUpdateAction, _p_FIX__MarketUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDUpdateAction, _p_FIX__MDUpdateActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplQueueAction, _p_FIX__ApplQueueActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionInst, _p_FIX__DiscretionInstTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PreviouslyReported, _p_FIX__PreviouslyReportedTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinTradeVol, _p_FIX__MinTradeVolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxTradeVol, _p_FIX__MaxTradeVolTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessCurr, _p_FIX__AllowableOneSidednessCurrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocNoOrdersType, _p_FIX__AllocNoOrdersTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteAckStatus, _p_FIX__QuoteAckStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesStatus, _p_FIX__TradSesStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollInquiryStatus, _p_FIX__CollInquiryStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteEntryStatus, _p_FIX__QuoteEntryStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteStatus, _p_FIX__QuoteStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmStatus, _p_FIX__ConfirmStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AffirmStatus, _p_FIX__AffirmStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosQtyStatus, _p_FIX__PosQtyStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityTradingStatus, _p_FIX__SecurityTradingStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocStatus, _p_FIX__AllocStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosReqStatus, _p_FIX__PosReqStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityStatus, _p_FIX__DerivativeSecurityStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityStatus, _p_FIX__SecurityStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecAckStatus, _p_FIX__ExecAckStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MoneyLaunderingStatus, _p_FIX__MoneyLaunderingStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplSeqNum, _p_FIX__ApplSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefSeqNum, _p_FIX__RefSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplLastSeqNum, _p_FIX__ApplLastSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplLastSeqNum, _p_FIX__RefApplLastSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplEndSeqNum, _p_FIX__ApplEndSeqNumTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingQty, _p_FIX__UnderlyingQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderBookingQty, _p_FIX__OrderBookingQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCPProgram, _p_FIX__UnderlyingCPProgramTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CPProgram, _p_FIX__CPProgramTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryPx, _p_FIX__MDEntryPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdvTransType, _p_FIX__AdvTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocTransType, _p_FIX__AllocTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOITransType, _p_FIX__IOITransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecTransType, _p_FIX__ExecTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidRequestTransType, _p_FIX__BidRequestTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistTransType, _p_FIX__RegistTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstTransType, _p_FIX__SettlInstTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligTransType, _p_FIX__SettlObligTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnTransType, _p_FIX__CollAsgnTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeReportTransType, _p_FIX__TradeReportTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmTransType, _p_FIX__ConfirmTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosTransType, _p_FIX__PosTransTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastForwardPoints2, _p_FIX__LastForwardPoints2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferForwardPoints2, _p_FIX__OfferForwardPoints2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidForwardPoints2, _p_FIX__BidForwardPoints2To_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAsgnID, _p_FIX__CollAsgnIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OpenClose, _p_FIX__OpenCloseTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocPositionEffect, _p_FIX__AllocPositionEffectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPositionEffect, _p_FIX__LegPositionEffectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PositionEffect, _p_FIX__PositionEffectTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested2PartySubIDs, _p_FIX__NoNested2PartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartySubIDs, _p_FIX__NoPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoInstrumentPartySubIDs, _p_FIX__NoInstrumentPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrumentPartySubIDs, _p_FIX__NoDerivativeInstrumentPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlPartySubIDs, _p_FIX__NoSettlPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested3PartySubIDs, _p_FIX__NoNested3PartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested4PartySubIDs, _p_FIX__NoNested4PartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNestedPartySubIDs, _p_FIX__NoNestedPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRootPartySubIDs, _p_FIX__NoRootPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoUndlyInstrumentPartySubIDs, _p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IncTaxInd, _p_FIX__IncTaxIndTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RepurchaseTerm, _p_FIX__RepurchaseTermTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRepurchaseTerm, _p_FIX__LegRepurchaseTermTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingRepurchaseTerm, _p_FIX__UnderlyingRepurchaseTermTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RelatdSym, _p_FIX__RelatdSymTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OpenCloseSettleFlag, _p_FIX__OpenCloseSettleFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistDetls, _p_FIX__RegistDetlsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplExtID, _p_FIX__ApplExtIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefaultApplExtID, _p_FIX__DefaultApplExtIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplExtID, _p_FIX__RefApplExtIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SenderSubID, _p_FIX__SenderSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligMode, _p_FIX__SettlObligModeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TerminationType, _p_FIX__TerminationTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MassActionType, _p_FIX__MassActionTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StipulationType, _p_FIX__StipulationTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStipulationType, _p_FIX__LegStipulationTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlObligID, _p_FIX__SettlObligIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryClOrdID, _p_FIX__SecondaryClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClOrdID, _p_FIX__ClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigClOrdID, _p_FIX__OrigClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NotAffOrigClOrdID, _p_FIX__NotAffOrigClOrdIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PaymentRemitterID, _p_FIX__PaymentRemitterIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidType, _p_FIX__BidTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerTradingSessionSubID, _p_FIX__TriggerTradingSessionSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingSessionSubID, _p_FIX__TradingSessionSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingTradingSessionSubID, _p_FIX__UnderlyingTradingSessionSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketID, _p_FIX__MarketIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TaxAdvantageType, _p_FIX__TaxAdvantageTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlDetails, _p_FIX__NoSettlDetailsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DayCumQty, _p_FIX__DayCumQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RndPx, _p_FIX__RndPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CumQty, _p_FIX__CumQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryPositionNo, _p_FIX__MDEntryPositionNoTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkPriceType, _p_FIX__BenchmarkPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegPriceType, _p_FIX__LegPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlPriceType, _p_FIX__SettlPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkPriceType, _p_FIX__LegBenchmarkPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuotePriceType, _p_FIX__QuotePriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__YieldRedemptionPriceType, _p_FIX__YieldRedemptionPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceType, _p_FIX__PriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegPriceType, _p_FIX__PegPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlPriceType, _p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExecPriceType, _p_FIX__ExecPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerPriceType, _p_FIX__TriggerPriceTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoAffectedOrders, _p_FIX__NoAffectedOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotalAffectedOrders, _p_FIX__TotalAffectedOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNotAffectedOrders, _p_FIX__NoNotAffectedOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NumberOfOrders, _p_FIX__NumberOfOrdersTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StreamAsgnType, _p_FIX__StreamAsgnTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityRequestResult, _p_FIX__SecurityRequestResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintResult, _p_FIX__PosMaintResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeRequestResult, _p_FIX__TradeRequestResultTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderDelayUnit, _p_FIX__OrderDelayUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerAction, _p_FIX__TriggerActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollAction, _p_FIX__CollActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintAction, _p_FIX__PosMaintActionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndCash, _p_FIX__EndCashTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefSubID, _p_FIX__RefSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OnBehalfOfSubID, _p_FIX__OnBehalfOfSubIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingDirtyPrice, _p_FIX__UnderlyingDirtyPriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderCapacityQty, _p_FIX__OrderCapacityQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerSecurityID, _p_FIX__TriggerSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSecurityID, _p_FIX__LegSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecurityID, _p_FIX__SecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityID, _p_FIX__DerivativeSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkSecurityID, _p_FIX__BenchmarkSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PegSecurityID, _p_FIX__PegSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityID, _p_FIX__UnderlyingSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityID, _p_FIX__UnderlyingLegSecurityIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PosMaintStatus, _p_FIX__PosMaintStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollStatus, _p_FIX__CollStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SessionStatus, _p_FIX__SessionStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeRequestStatus, _p_FIX__TradeRequestStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListOrderStatus, _p_FIX__ListOrderStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UserStatus, _p_FIX__UserStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRptStatus, _p_FIX__TrdRptStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FinancialStatus, _p_FIX__FinancialStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementStatus, _p_FIX__UnderlyingSettlementStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MatchStatus, _p_FIX__MatchStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrdStatus, _p_FIX__OrdStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RegistStatus, _p_FIX__RegistStatusTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrderAvgPx, _p_FIX__OrderAvgPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryRefID, _p_FIX__MDEntryRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecureDataLen, _p_FIX__SecureDataLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__XmlDataLen, _p_FIX__XmlDataLenTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MultiLegRptTypeReq, _p_FIX__MultiLegRptTypeReqTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityTime, _p_FIX__MaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityTime, _p_FIX__UnderlyingMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityTime, _p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegMaturityTime, _p_FIX__LegMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityTime, _p_FIX__DerivativeMaturityTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTickRules, _p_FIX__NoTickRulesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ClearingBusinessDate, _p_FIX__ClearingBusinessDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeNTPositionLimit, _p_FIX__DerivativeNTPositionLimitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PositionLimit, _p_FIX__PositionLimitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NTPositionLimit, _p_FIX__NTPositionLimitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePositionLimit, _p_FIX__DerivativePositionLimitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteSetID, _p_FIX__QuoteSetIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AdvId, _p_FIX__AdvIdTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Quantity, _p_FIX__QuantityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingAdjustedQuantity, _p_FIX__UnderlyingAdjustedQuantityTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPayAmount, _p_FIX__UnderlyingPayAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeOptPayAmount, _p_FIX__DerivativeOptPayAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingDeliveryAmount, _p_FIX__UnderlyingDeliveryAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OptPayAmount, _p_FIX__OptPayAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ConfirmRefID, _p_FIX__ConfirmRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoContAmts, _p_FIX__NoContAmtsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocType, _p_FIX__AllocTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IndividualAllocType, _p_FIX__IndividualAllocTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SharedCommission, _p_FIX__SharedCommissionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Commission, _p_FIX__CommissionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DiscretionOffset, _p_FIX__DiscretionOffsetTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIRefID, _p_FIX__IOIRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BasisFeaturePrice, _p_FIX__BasisFeaturePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Product, _p_FIX__ProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingProduct, _p_FIX__UnderlyingProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeProduct, _p_FIX__DerivativeProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegProduct, _p_FIX__LegProductTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LocateReqd, _p_FIX__LocateReqdTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__Concession, _p_FIX__ConcessionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CommType, _p_FIX__CommTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxPriceVariation, _p_FIX__MaxPriceVariationTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigTradeHandlingInstr, _p_FIX__OrigTradeHandlingInstrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeHandlingInstr, _p_FIX__TradeHandlingInstrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDFeedType, _p_FIX__MDFeedTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TriggerPriceTypeScope, _p_FIX__TriggerPriceTypeScopeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestamp, _p_FIX__SideTrdRegTimestampTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TrdRegTimestamp, _p_FIX__TrdRegTimestampTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetChgPrevDay, _p_FIX__NetChgPrevDayTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpQty, _p_FIX__ExpQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AssignmentUnit, _p_FIX__AssignmentUnitTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePriceBoundaryMethod, _p_FIX__StrikePriceBoundaryMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MultilegPriceMethod, _p_FIX__MultilegPriceMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceBoundaryMethod, _p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocMethod, _p_FIX__AllocMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradSesMethod, _p_FIX__TradSesMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativePriceQuoteMethod, _p_FIX__DerivativePriceQuoteMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PriceQuoteMethod, _p_FIX__PriceQuoteMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PreallocMethod, _p_FIX__PreallocMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExerciseMethod, _p_FIX__ExerciseMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayMethod, _p_FIX__DisplayMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RefApplReqID, _p_FIX__RefApplReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplReqID, _p_FIX__ApplReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollReqID, _p_FIX__CollReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoBidComponents, _p_FIX__NoBidComponentsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LiquidityValue, _p_FIX__LiquidityValueTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradeDate, _p_FIX__TradeDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigTradeDate, _p_FIX__OrigTradeDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListName, _p_FIX__ListNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PctAtRisk, _p_FIX__PctAtRiskTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UtcTimeOnlyField, _p_FIX__UtcTimeOnlyFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TotNoRelatedSym, _p_FIX__TotNoRelatedSymTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRelatedSym, _p_FIX__NoRelatedSymTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding, _p_FIX__UnderlyingOriginalNotionalPercentageOutstandingTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDReqID, _p_FIX__MDReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegCurrencyRatio, _p_FIX__LegCurrencyRatioTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CurrencyRatio, _p_FIX__CurrencyRatioTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AllocNetMoney, _p_FIX__AllocNetMoneyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NetMoney, _p_FIX__NetMoneyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityNetMoney, _p_FIX__MaturityNetMoneyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkCurveName, _p_FIX__BenchmarkCurveNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurveName, _p_FIX__LegBenchmarkCurveNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigPosReqRefID, _p_FIX__OrigPosReqRefIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__RatioQty, _p_FIX__RatioQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegRatioQty, _p_FIX__LegRatioQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AggregatedBook, _p_FIX__AggregatedBookTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurvePoint, _p_FIX__LegBenchmarkCurvePointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BenchmarkCurvePoint, _p_FIX__BenchmarkCurvePointTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinPriceIncrementAmount, _p_FIX__MinPriceIncrementAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OptPayoutAmount, _p_FIX__OptPayoutAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCollectAmount, _p_FIX__UnderlyingCollectAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexOptPayoutAmount, _p_FIX__ComplexOptPayoutAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ThresholdAmount, _p_FIX__ThresholdAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeMinPriceIncrementAmount, _p_FIX__DerivativeMinPriceIncrementAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingCashAmount, _p_FIX__UnderlyingCashAmountTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OpenCloseSettlFlag, _p_FIX__OpenCloseSettlFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ApplResendFlag, _p_FIX__ApplResendFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DisplayMinIncr, _p_FIX__DisplayMinIncrTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxShow, _p_FIX__MaxShowTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoExecs, _p_FIX__NoExecsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrFxRate, _p_FIX__SettlCurrFxRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrOfferFxRate, _p_FIX__SettlCurrOfferFxRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlCurrBidFxRate, _p_FIX__SettlCurrBidFxRateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeskID, _p_FIX__DeskIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DeliveryForm, _p_FIX__DeliveryFormTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__HostCrossID, _p_FIX__HostCrossIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OrigCrossID, _p_FIX__OrigCrossIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CrossID, _p_FIX__CrossIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TargetStrategy, _p_FIX__TargetStrategyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentContactName, _p_FIX__CashSettlAgentContactNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashSettlAgentAcctName, _p_FIX__CashSettlAgentAcctNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CashDistribAgentAcctName, _p_FIX__CashDistribAgentAcctNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentAcctName, _p_FIX__SecuritySettlAgentAcctNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentContactName, _p_FIX__SecuritySettlAgentContactNameTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoRootPartyIDs, _p_FIX__NoRootPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoTargetPartyIDs, _p_FIX__NoTargetPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested4PartyIDs, _p_FIX__NoNested4PartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNestedPartyIDs, _p_FIX__NoNestedPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested2PartyIDs, _p_FIX__NoNested2PartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoSettlPartyIDs, _p_FIX__NoSettlPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoPartyIDs, _p_FIX__NoPartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoNested3PartyIDs, _p_FIX__NoNested3PartyIDsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoOfSecSizes, _p_FIX__NoOfSecSizesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FirstPx, _p_FIX__FirstPxTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgPrxPrecision, _p_FIX__AvgPrxPrecisionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AvgPxPrecision, _p_FIX__AvgPxPrecisionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingLegStrikePrice, _p_FIX__UnderlyingLegStrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegStrikePrice, _p_FIX__LegStrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeStrikePrice, _p_FIX__DerivativeStrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SecondaryTradingReferencePrice, _p_FIX__SecondaryTradingReferencePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingStrikePrice, _p_FIX__UnderlyingStrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePrice, _p_FIX__StrikePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TradingReferencePrice, _p_FIX__TradingReferencePriceTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePriceBoundaryPrecision, _p_FIX__StrikePriceBoundaryPrecisionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceBoundaryPrecision, _p_FIX__ComplexEventPriceBoundaryPrecisionTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearIncrementUnits, _p_FIX__MaturityMonthYearIncrementUnitsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryBuyer, _p_FIX__MDEntryBuyerTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegSettlDate, _p_FIX__LegSettlDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlDate, _p_FIX__SettlDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EndDate, _p_FIX__EndDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__TestReqID, _p_FIX__TestReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MarketReqID, _p_FIX__MarketReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlInstReqID, _p_FIX__SettlInstReqIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ComplexEventEndDate, _p_FIX__ComplexEventEndDateTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LeavesQty, _p_FIX__LeavesQtyTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIID, _p_FIX__IOIIDTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrAttribType, _p_FIX__DerivativeInstrAttribTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NestedInstrAttribType, _p_FIX__NestedInstrAttribTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrAttribType, _p_FIX__InstrAttribTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ProcessCode, _p_FIX__ProcessCodeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UtcDateField, _p_FIX__UtcDateFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DoubleField, _p_FIX__DoubleFieldTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ValueOfFutures, _p_FIX__ValueOfFuturesTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__NoCollInquiryQualifier, _p_FIX__NoCollInquiryQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__CollInquiryQualifier, _p_FIX__CollInquiryQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__QuoteQualifier, _p_FIX__QuoteQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__IOIQualifier, _p_FIX__IOIQualifierTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegGrossTradeAmt, _p_FIX__LegGrossTradeAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SideGrossTradeAmt, _p_FIX__SideGrossTradeAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__GrossTradeAmt, _p_FIX__GrossTradeAmtTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MinBidSize, _p_FIX__MinBidSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DefBidSize, _p_FIX__DefBidSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidSize, _p_FIX__BidSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ExpType, _p_FIX__ExpTypeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastUpdateTime, _p_FIX__LastUpdateTimeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PossDupFlag, _p_FIX__PossDupFlagTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceDeterminationMethod, _p_FIX__UnderlyingPriceDeterminationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__PaymentMethod, _p_FIX__PaymentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__StrikePriceDeterminationMethod, _p_FIX__StrikePriceDeterminationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptMethod, _p_FIX__EncryptMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ListMethod, _p_FIX__ListMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DistribPaymentMethod, _p_FIX__DistribPaymentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__EncryptedPasswordMethod, _p_FIX__EncryptedPasswordMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeListMethod, _p_FIX__DerivativeListMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlMethod, _p_FIX__UnderlyingSettlMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeFuturesValuationMethod, _p_FIX__DerivativeFuturesValuationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__ValuationMethod, _p_FIX__ValuationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__FuturesValuationMethod, _p_FIX__FuturesValuationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeValuationMethod, _p_FIX__DerivativeValuationMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__AssignmentMethod, _p_FIX__AssignmentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SettlMethod, _p_FIX__SettlMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeInstrmtAssignmentMethod, _p_FIX__DerivativeInstrmtAssignmentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__InstrmtAssignmentMethod, _p_FIX__InstrmtAssignmentMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__DerivativeSettlMethod, _p_FIX__DerivativeSettlMethodTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MaxMessageSize, _p_FIX__MaxMessageSizeTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastSwapPoints, _p_FIX__LastSwapPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegBidForwardPoints, _p_FIX__LegBidForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LastForwardPoints, _p_FIX__LastForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__SwapPoints, _p_FIX__SwapPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegLastForwardPoints, _p_FIX__LegLastForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__LegOfferForwardPoints, _p_FIX__LegOfferForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidSwapPoints, _p_FIX__BidSwapPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferSwapPoints, _p_FIX__OfferSwapPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__BidForwardPoints, _p_FIX__BidForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__MDEntryForwardPoints, _p_FIX__MDEntryForwardPointsTo_p_FIX__FieldBase, 0, 0},  {&_swigt__p_FIX__OfferForwardPoints, _p_FIX__OfferForwardPointsTo_p_FIX__FieldBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldConvertError[] = {  {&_swigt__p_FIX__FieldConvertError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldMap[] = {  {&_swigt__p_FIX__Group, _p_FIX__GroupTo_p_FIX__FieldMap, 0, 0},  {&_swigt__p_FIX__Header, _p_FIX__HeaderTo_p_FIX__FieldMap, 0, 0},  {&_swigt__p_FIX__Trailer, _p_FIX__TrailerTo_p_FIX__FieldMap, 0, 0},  {&_swigt__p_FIX__Message, _p_FIX__MessageTo_p_FIX__FieldMap, 0, 0},  {&_swigt__p_FIX__FieldMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldMap__Fields__const_iterator[] = {  {&_swigt__p_FIX__FieldMap__Fields__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldMap__Groups__const_iterator[] = {  {&_swigt__p_FIX__FieldMap__Groups__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FieldNotFound[] = {  {&_swigt__p_FIX__FieldNotFound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FileLog[] = {  {&_swigt__p_FIX__FileLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FileLogFactory[] = {  {&_swigt__p_FIX__FileLogFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FileStore[] = {  {&_swigt__p_FIX__FileStore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FileStoreFactory[] = {  {&_swigt__p_FIX__FileStoreFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FillExecID[] = {  {&_swigt__p_FIX__FillExecID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FillLiquidityInd[] = {  {&_swigt__p_FIX__FillLiquidityInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FillPx[] = {  {&_swigt__p_FIX__FillPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FillQty[] = {  {&_swigt__p_FIX__FillQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FinancialStatus[] = {  {&_swigt__p_FIX__FinancialStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FirmTradeID[] = {  {&_swigt__p_FIX__FirmTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FirstPx[] = {  {&_swigt__p_FIX__FirstPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FlexProductEligibilityIndicator[] = {  {&_swigt__p_FIX__FlexProductEligibilityIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FlexibleIndicator[] = {  {&_swigt__p_FIX__FlexibleIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FloorPrice[] = {  {&_swigt__p_FIX__FloorPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FlowScheduleType[] = {  {&_swigt__p_FIX__FlowScheduleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ForexReq[] = {  {&_swigt__p_FIX__ForexReq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FundRenewWaiv[] = {  {&_swigt__p_FIX__FundRenewWaiv, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FutSettDate[] = {  {&_swigt__p_FIX__FutSettDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FutSettDate2[] = {  {&_swigt__p_FIX__FutSettDate2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__FuturesValuationMethod[] = {  {&_swigt__p_FIX__FuturesValuationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__GTBookingInst[] = {  {&_swigt__p_FIX__GTBookingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__GapFillFlag[] = {  {&_swigt__p_FIX__GapFillFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__GrossTradeAmt[] = {  {&_swigt__p_FIX__GrossTradeAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Group[] = {  {&_swigt__p_FIX__Group, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HaltReasonChar[] = {  {&_swigt__p_FIX__HaltReasonChar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HaltReasonInt[] = {  {&_swigt__p_FIX__HaltReasonInt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HandlInst[] = {  {&_swigt__p_FIX__HandlInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Header[] = {  {&_swigt__p_FIX__Header, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Headline[] = {  {&_swigt__p_FIX__Headline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HeartBtInt[] = {  {&_swigt__p_FIX__HeartBtInt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HighLimitPrice[] = {  {&_swigt__p_FIX__HighLimitPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HighPx[] = {  {&_swigt__p_FIX__HighPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HopCompID[] = {  {&_swigt__p_FIX__HopCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HopRefID[] = {  {&_swigt__p_FIX__HopRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HopSendingTime[] = {  {&_swigt__p_FIX__HopSendingTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__HostCrossID[] = {  {&_swigt__p_FIX__HostCrossID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IDSource[] = {  {&_swigt__p_FIX__IDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__INT[] = {  {&_swigt__p_FIX__INT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOException[] = {  {&_swigt__p_FIX__IOException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIID[] = {  {&_swigt__p_FIX__IOIID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOINaturalFlag[] = {  {&_swigt__p_FIX__IOINaturalFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIOthSvc[] = {  {&_swigt__p_FIX__IOIOthSvc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIQltyInd[] = {  {&_swigt__p_FIX__IOIQltyInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIQty[] = {  {&_swigt__p_FIX__IOIQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIQualifier[] = {  {&_swigt__p_FIX__IOIQualifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIRefID[] = {  {&_swigt__p_FIX__IOIRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIShares[] = {  {&_swigt__p_FIX__IOIShares, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOITransType[] = {  {&_swigt__p_FIX__IOITransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IOIid[] = {  {&_swigt__p_FIX__IOIid, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ImpliedMarketIndicator[] = {  {&_swigt__p_FIX__ImpliedMarketIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InViewOfCommon[] = {  {&_swigt__p_FIX__InViewOfCommon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IncTaxInd[] = {  {&_swigt__p_FIX__IncTaxInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IncorrectDataFormat[] = {  {&_swigt__p_FIX__IncorrectDataFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IncorrectMessageStructure[] = {  {&_swigt__p_FIX__IncorrectMessageStructure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IncorrectTagValue[] = {  {&_swigt__p_FIX__IncorrectTagValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IndividualAllocID[] = {  {&_swigt__p_FIX__IndividualAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IndividualAllocRejCode[] = {  {&_swigt__p_FIX__IndividualAllocRejCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IndividualAllocType[] = {  {&_swigt__p_FIX__IndividualAllocType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Initiator[] = {  {&_swigt__p_FIX__Initiator, 0, 0, 0},  {&_swigt__p_FIX__SocketInitiator, _p_FIX__SocketInitiatorTo_p_FIX__Initiator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InputSource[] = {  {&_swigt__p_FIX__InputSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrAttribType[] = {  {&_swigt__p_FIX__InstrAttribType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrAttribValue[] = {  {&_swigt__p_FIX__InstrAttribValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrRegistry[] = {  {&_swigt__p_FIX__InstrRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrmtAssignmentMethod[] = {  {&_swigt__p_FIX__InstrmtAssignmentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartyID[] = {  {&_swigt__p_FIX__InstrumentPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartyIDSource[] = {  {&_swigt__p_FIX__InstrumentPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartyRole[] = {  {&_swigt__p_FIX__InstrumentPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartySubID[] = {  {&_swigt__p_FIX__InstrumentPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InstrumentPartySubIDType[] = {  {&_swigt__p_FIX__InstrumentPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IntField[] = {  {&_swigt__p_FIX__NoNewsRefIDs, _p_FIX__NoNewsRefIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPositions, _p_FIX__NoPositionsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaxPriceLevels, _p_FIX__MaxPriceLevelsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMiscFees, _p_FIX__NoMiscFeesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ClearingInstruction, _p_FIX__ClearingInstructionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoComplexEventTimes, _p_FIX__NoComplexEventTimesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDSecSizeType, _p_FIX__MDSecSizeTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RepurchaseTerm, _p_FIX__RepurchaseTermTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegRepurchaseTerm, _p_FIX__LegRepurchaseTermTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingRepurchaseTerm, _p_FIX__UnderlyingRepurchaseTermTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RptSeq, _p_FIX__RptSeqTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NumBidders, _p_FIX__NumBiddersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MultilegModel, _p_FIX__MultilegModelTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDPriceLevel, _p_FIX__MDPriceLevelTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteResponseLevel, _p_FIX__QuoteResponseLevelTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ComplexEventCondition, _p_FIX__ComplexEventConditionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OptPayoutType, _p_FIX__OptPayoutTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideValueInd, _p_FIX__SideValueIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoContAmts, _p_FIX__NoContAmtsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ContractMultiplierUnit, _p_FIX__ContractMultiplierUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegContractMultiplierUnit, _p_FIX__LegContractMultiplierUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeContractMultiplierUnit, _p_FIX__DerivativeContractMultiplierUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingContractMultiplierUnit, _p_FIX__UnderlyingContractMultiplierUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplEndSeqNum, _p_FIX__ApplEndSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefApplLastSeqNum, _p_FIX__RefApplLastSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplLastSeqNum, _p_FIX__ApplLastSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefSeqNum, _p_FIX__RefSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplSeqNum, _p_FIX__ApplSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NextExpectedMsgSeqNum, _p_FIX__NextExpectedMsgSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplNewSeqNum, _p_FIX__ApplNewSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MsgSeqNum, _p_FIX__MsgSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplBegSeqNum, _p_FIX__ApplBegSeqNumTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoExecInstRules, _p_FIX__NoExecInstRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoQuoteEntries, _p_FIX__TotNoQuoteEntriesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMDEntries, _p_FIX__NoMDEntriesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotQuoteEntries, _p_FIX__TotQuoteEntriesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoQuoteEntries, _p_FIX__NoQuoteEntriesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__HopRefID, _p_FIX__HopRefIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SessionRejectReason, _p_FIX__SessionRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListRejectReason, _p_FIX__ListRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassActionRejectReason, _p_FIX__MassActionRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ConfirmRejReason, _p_FIX__ConfirmRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CxlRejReason, _p_FIX__CxlRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StreamAsgnRejReason, _p_FIX__StreamAsgnRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteEntryRejectReason, _p_FIX__QuoteEntryRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExecRestatementReason, _p_FIX__ExecRestatementReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrdRejReason, _p_FIX__OrdRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeReportRejectReason, _p_FIX__TradeReportRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteRejectReason, _p_FIX__QuoteRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAsgnReason, _p_FIX__CollAsgnReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassCancelRejectReason, _p_FIX__MassCancelRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesStatusRejReason, _p_FIX__TradSesStatusRejReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteRequestRejectReason, _p_FIX__QuoteRequestRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAsgnRejectReason, _p_FIX__CollAsgnRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefOrdIDReason, _p_FIX__RefOrdIDReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BusinessRejectReason, _p_FIX__BusinessRejectReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoContraBrokers, _p_FIX__NoContraBrokersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ShortSaleReason, _p_FIX__ShortSaleReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocCancReplaceReason, _p_FIX__AllocCancReplaceReasonTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlementCycleNo, _p_FIX__SettlementCycleNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTrdRegTimestamps, _p_FIX__NoTrdRegTimestampsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoAffectedOrders, _p_FIX__NoAffectedOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotalAffectedOrders, _p_FIX__TotalAffectedOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNotAffectedOrders, _p_FIX__NoNotAffectedOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NumberOfOrders, _p_FIX__NumberOfOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoOrders, _p_FIX__TotNoOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoOrders, _p_FIX__NoOrdersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoApplIDs, _p_FIX__NoApplIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplQueueResolution, _p_FIX__ApplQueueResolutionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AvgPrxPrecision, _p_FIX__AvgPrxPrecisionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AvgPxPrecision, _p_FIX__AvgPxPrecisionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Adjustment, _p_FIX__AdjustmentTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RegistRejReasonCode, _p_FIX__RegistRejReasonCodeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MiscFeeBasis, _p_FIX__MiscFeeBasisTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListStatusType, _p_FIX__ListStatusTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoQuoteSets, _p_FIX__NoQuoteSetsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExpType, _p_FIX__ExpTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedIssuerLen, _p_FIX__EncodedIssuerLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedLegIssuerLen, _p_FIX__EncodedLegIssuerLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingIssuerLen, _p_FIX__EncodedUnderlyingIssuerLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedIssuerLen, _p_FIX__DerivativeEncodedIssuerLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DeliveryForm, _p_FIX__DeliveryFormTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegLimitType, _p_FIX__PegLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionLimitType, _p_FIX__DiscretionLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecondaryPriceLimitType, _p_FIX__SecondaryPriceLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PriceLimitType, _p_FIX__PriceLimitTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegProduct, _p_FIX__LegProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeProduct, _p_FIX__DerivativeProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingProduct, _p_FIX__UnderlyingProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Product, _p_FIX__ProductTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTradingSessions, _p_FIX__NoTradingSessionsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__IncTaxInd, _p_FIX__IncTaxIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoCapacities, _p_FIX__NoCapacitiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlPriceType, _p_FIX__UnderlyingSettlPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegPriceType, _p_FIX__PegPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PriceType, _p_FIX__PriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__YieldRedemptionPriceType, _p_FIX__YieldRedemptionPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuotePriceType, _p_FIX__QuotePriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkPriceType, _p_FIX__LegBenchmarkPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlPriceType, _p_FIX__SettlPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegPriceType, _p_FIX__LegPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BenchmarkPriceType, _p_FIX__BenchmarkPriceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdRegTimestampType, _p_FIX__TrdRegTimestampTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestampType, _p_FIX__SideTrdRegTimestampTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RateSourceType, _p_FIX__RateSourceTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassActionType, _p_FIX__MassActionTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TerminationType, _p_FIX__TerminationTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSecurityAltID, _p_FIX__NoSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyingSecurityAltID, _p_FIX__NoUnderlyingSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLegSecurityAltID, _p_FIX__NoLegSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeSecurityAltID, _p_FIX__NoDerivativeSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyingLegSecurityAltID, _p_FIX__NoUnderlyingLegSecurityAltIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoAsgnReqs, _p_FIX__NoAsgnReqsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMatchRules, _p_FIX__NoMatchRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityRequestType, _p_FIX__SecurityRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeRequestType, _p_FIX__TradeRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UserRequestType, _p_FIX__UserRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NetworkRequestType, _p_FIX__NetworkRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityListType, _p_FIX__SecurityListTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteRequestType, _p_FIX__QuoteRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityListRequestType, _p_FIX__SecurityListRequestTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__HeartBtInt, _p_FIX__HeartBtIntTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StatsType, _p_FIX__StatsTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocSettlInstType, _p_FIX__AllocSettlInstTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegPutOrCall, _p_FIX__LegPutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegPutOrCall, _p_FIX__UnderlyingLegPutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativePutOrCall, _p_FIX__DerivativePutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PutOrCall, _p_FIX__PutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingPutOrCall, _p_FIX__UnderlyingPutOrCallTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceTimeType, _p_FIX__ComplexEventPriceTimeTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LiquidityIndType, _p_FIX__LiquidityIndTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ContingencyType, _p_FIX__ContingencyTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeAllocIndicator, _p_FIX__TradeAllocIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradePublishIndicator, _p_FIX__TradePublishIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ImpliedMarketIndicator, _p_FIX__ImpliedMarketIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AvgPxIndicator, _p_FIX__AvgPxIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PriorityIndicator, _p_FIX__PriorityIndicatorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdRptStatus, _p_FIX__TrdRptStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UserStatus, _p_FIX__UserStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListOrderStatus, _p_FIX__ListOrderStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeRequestStatus, _p_FIX__TradeRequestStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SessionStatus, _p_FIX__SessionStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollStatus, _p_FIX__CollStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosMaintStatus, _p_FIX__PosMaintStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExerciseStyle, _p_FIX__ExerciseStyleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StrikeExerciseStyle, _p_FIX__StrikeExerciseStyleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegExerciseStyle, _p_FIX__LegExerciseStyleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingExerciseStyle, _p_FIX__UnderlyingExerciseStyleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CustOrderCapacity, _p_FIX__CustOrderCapacityTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrigCustOrderCapacity, _p_FIX__OrigCustOrderCapacityTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlInst, _p_FIX__NoSettlInstTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__IndividualAllocType, _p_FIX__IndividualAllocTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocType, _p_FIX__AllocTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoComplexEventDates, _p_FIX__NoComplexEventDatesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteAckStatus, _p_FIX__QuoteAckStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesStatus, _p_FIX__TradSesStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollInquiryStatus, _p_FIX__CollInquiryStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteEntryStatus, _p_FIX__QuoteEntryStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteStatus, _p_FIX__QuoteStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ConfirmStatus, _p_FIX__ConfirmStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AffirmStatus, _p_FIX__AffirmStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosQtyStatus, _p_FIX__PosQtyStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosReqStatus, _p_FIX__PosReqStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocStatus, _p_FIX__AllocStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityTradingStatus, _p_FIX__SecurityTradingStatusTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__IntField, 0, 0, 0},  {&_swigt__p_FIX__ListSeqNo, _p_FIX__ListSeqNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaxMessageSize, _p_FIX__MaxMessageSizeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MarketDepth, _p_FIX__MarketDepthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplResponseError, _p_FIX__ApplResponseErrorTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollApplType, _p_FIX__CollApplTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__GTBookingInst, _p_FIX__GTBookingInstTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NumTickets, _p_FIX__NumTicketsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegSwapType, _p_FIX__LegSwapTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrderDelay, _p_FIX__OrderDelayTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTrades, _p_FIX__NoTradesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityXMLLen, _p_FIX__SecurityXMLLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXMLLen, _p_FIX__DerivativeSecurityXMLLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearFormat, _p_FIX__MaturityMonthYearFormatTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteCancelType, _p_FIX__QuoteCancelTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ModelType, _p_FIX__ModelTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeReportType, _p_FIX__TradeReportTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ResponseTransportType, _p_FIX__ResponseTransportTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocReportType, _p_FIX__AllocReportTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplReportType, _p_FIX__ApplReportTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MultiLegRptTypeReq, _p_FIX__MultiLegRptTypeReqTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoHops, _p_FIX__NoHopsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CrossType, _p_FIX__CrossTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRateSources, _p_FIX__NoRateSourcesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingFlowScheduleType, _p_FIX__UnderlyingFlowScheduleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__FlowScheduleType, _p_FIX__FlowScheduleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegFlowScheduleType, _p_FIX__LegFlowScheduleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeFlowScheduleType, _p_FIX__DerivativeFlowScheduleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TickRuleType, _p_FIX__TickRuleTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__InstrumentPartyRole, _p_FIX__InstrumentPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested4PartyRole, _p_FIX__Nested4PartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NestedPartyRole, _p_FIX__NestedPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested3PartyRole, _p_FIX__Nested3PartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PartyRole, _p_FIX__PartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyRole, _p_FIX__DerivativeInstrumentPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlPartyRole, _p_FIX__SettlPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdRepPartyRole, _p_FIX__TrdRepPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RootPartyRole, _p_FIX__RootPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyRole, _p_FIX__UndlyInstrumentPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested2PartyRole, _p_FIX__Nested2PartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TargetPartyRole, _p_FIX__TargetPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyRole, _p_FIX__UnderlyingInstrumentPartyRoleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingSecurityDescLen, _p_FIX__EncodedUnderlyingSecurityDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedLegSecurityDescLen, _p_FIX__EncodedLegSecurityDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedSecurityDescLen, _p_FIX__DerivativeEncodedSecurityDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedMktSegmDescLen, _p_FIX__EncodedMktSegmDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedSecurityListDescLen, _p_FIX__EncodedSecurityListDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDescLen, _p_FIX__EncodedSecurityDescLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlObligMode, _p_FIX__SettlObligModeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegNumber, _p_FIX__LegNumberTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StatusValue, _p_FIX__StatusValueTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideQty, _p_FIX__SideQtyTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideLiquidityInd, _p_FIX__SideLiquidityIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LastLiquidityInd, _p_FIX__LastLiquidityIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__FillLiquidityInd, _p_FIX__FillLiquidityIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoCollInquiryQualifier, _p_FIX__NoCollInquiryQualifierTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollInquiryQualifier, _p_FIX__CollInquiryQualifierTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StandInstDbType, _p_FIX__StandInstDbTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMarketSegments, _p_FIX__NoMarketSegmentsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TargetStrategy, _p_FIX__TargetStrategyTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested2PartySubIDs, _p_FIX__NoNested2PartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPartySubIDs, _p_FIX__NoPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoInstrumentPartySubIDs, _p_FIX__NoInstrumentPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrumentPartySubIDs, _p_FIX__NoDerivativeInstrumentPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlPartySubIDs, _p_FIX__NoSettlPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested3PartySubIDs, _p_FIX__NoNested3PartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested4PartySubIDs, _p_FIX__NoNested4PartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNestedPartySubIDs, _p_FIX__NoNestedPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRootPartySubIDs, _p_FIX__NoRootPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUndlyInstrumentPartySubIDs, _p_FIX__NoUndlyInstrumentPartySubIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionMoveType, _p_FIX__DiscretionMoveTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegMoveType, _p_FIX__PegMoveTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPosAmt, _p_FIX__NoPosAmtTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocNoOrdersType, _p_FIX__AllocNoOrdersTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListNoOrds, _p_FIX__ListNoOrdsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSideTrdRegTS, _p_FIX__NoSideTrdRegTSTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoFills, _p_FIX__TotNoFillsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoFills, _p_FIX__NoFillsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedHeadlineLen, _p_FIX__EncodedHeadlineLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedListExecInstLen, _p_FIX__EncodedListExecInstLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SellerDays, _p_FIX__SellerDaysTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceDeterminationMethod, _p_FIX__UnderlyingPriceDeterminationMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PaymentMethod, _p_FIX__PaymentMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StrikePriceDeterminationMethod, _p_FIX__StrikePriceDeterminationMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncryptMethod, _p_FIX__EncryptMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ListMethod, _p_FIX__ListMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DistribPaymentMethod, _p_FIX__DistribPaymentMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncryptedPasswordMethod, _p_FIX__EncryptedPasswordMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeListMethod, _p_FIX__DerivativeListMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StrikePriceBoundaryMethod, _p_FIX__StrikePriceBoundaryMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MultilegPriceMethod, _p_FIX__MultilegPriceMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ComplexEventPriceBoundaryMethod, _p_FIX__ComplexEventPriceBoundaryMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocMethod, _p_FIX__AllocMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesMethod, _p_FIX__TradSesMethodTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LastMsgSeqNumProcessed, _p_FIX__LastMsgSeqNumProcessedTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlInstReqRejCode, _p_FIX__SettlInstReqRejCodeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocRejCode, _p_FIX__AllocRejCodeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__IndividualAllocRejCode, _p_FIX__IndividualAllocRejCodeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRegistDtls, _p_FIX__NoRegistDtlsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoAllocs, _p_FIX__TotNoAllocsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLegAllocs, _p_FIX__NoLegAllocsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoAllocs, _p_FIX__NoAllocsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMsgTypes, _p_FIX__NoMsgTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDBookType, _p_FIX__MDBookTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDSubBookType, _p_FIX__MDSubBookTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoInstrAttrib, _p_FIX__NoInstrAttribTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNestedInstrAttrib, _p_FIX__NoNestedInstrAttribTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrAttrib, _p_FIX__NoDerivativeInstrAttribTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyings, _p_FIX__NoUnderlyingsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoOfLegUnderlyings, _p_FIX__NoOfLegUnderlyingsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoCompIDs, _p_FIX__NoCompIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStrikeRules, _p_FIX__NoStrikeRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTimeInForceRules, _p_FIX__NoTimeInForceRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLotTypeRules, _p_FIX__NoLotTypeRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoOrdTypeRules, _p_FIX__NoOrdTypeRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoExpiration, _p_FIX__NoExpirationTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeInstrumentParties, _p_FIX__NoDerivativeInstrumentPartiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUndlyInstrumentParties, _p_FIX__NoUndlyInstrumentPartiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoInstrumentParties, _p_FIX__NoInstrumentPartiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncryptedNewPasswordLen, _p_FIX__EncryptedNewPasswordLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncryptedPasswordLen, _p_FIX__EncryptedPasswordLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRootPartyIDs, _p_FIX__NoRootPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTargetPartyIDs, _p_FIX__NoTargetPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested4PartyIDs, _p_FIX__NoNested4PartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNestedPartyIDs, _p_FIX__NoNestedPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested2PartyIDs, _p_FIX__NoNested2PartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlPartyIDs, _p_FIX__NoSettlPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoPartyIDs, _p_FIX__NoPartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoNested3PartyIDs, _p_FIX__NoNested3PartyIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStrategyParameters, _p_FIX__NoStrategyParametersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLegs, _p_FIX__NoLegsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegRoundDirection, _p_FIX__PegRoundDirectionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionRoundDirection, _p_FIX__DiscretionRoundDirectionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideTrdSubTyp, _p_FIX__SideTrdSubTypTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoBidComponents, _p_FIX__NoBidComponentsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlOblig, _p_FIX__NoSettlObligTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegOffsetType, _p_FIX__PegOffsetTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionOffsetType, _p_FIX__DiscretionOffsetTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CustomerOrFirm, _p_FIX__CustomerOrFirmTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesMode, _p_FIX__TradSesModeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PegScope, _p_FIX__PegScopeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityReportID, _p_FIX__SecurityReportIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDReportID, _p_FIX__MDReportIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocLinkType, _p_FIX__AllocLinkTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyingAmounts, _p_FIX__NoUnderlyingAmountsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoClearingInstructions, _p_FIX__NoClearingInstructionsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDQuoteType, _p_FIX__MDQuoteTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDUpdateType, _p_FIX__MDUpdateTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteType, _p_FIX__QuoteTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StreamAsgnAckType, _p_FIX__StreamAsgnAckTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuoteRespType, _p_FIX__QuoteRespTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAsgnRespType, _p_FIX__CollAsgnRespTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMaturityRules, _p_FIX__NoMaturityRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideLastQty, _p_FIX__SideLastQtyTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotalNumPosReports, _p_FIX__TotalNumPosReportsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNumReports, _p_FIX__TotNumReportsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNumAssignmentReports, _p_FIX__TotNumAssignmentReportsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNumTradeReports, _p_FIX__TotNumTradeReportsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__XmlDataLen, _p_FIX__XmlDataLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecureDataLen, _p_FIX__SecureDataLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CoveredOrUncovered, _p_FIX__CoveredOrUncoveredTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LegCoveredOrUncovered, _p_FIX__LegCoveredOrUncoveredTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTradingSessionRules, _p_FIX__NoTradingSessionRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradSesEvent, _p_FIX__TradSesEventTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExpirationQtyType, _p_FIX__ExpirationQtyTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QtyType, _p_FIX__QtyTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__QuantityType, _p_FIX__QuantityTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSettlDetails, _p_FIX__NoSettlDetailsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CPProgram, _p_FIX__CPProgramTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplTotalMessageCount, _p_FIX__ApplTotalMessageCountTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearIncrement, _p_FIX__MaturityMonthYearIncrementTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityResponseType, _p_FIX__SecurityResponseTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplResponseType, _p_FIX__ApplResponseTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplQueueDepth, _p_FIX__ApplQueueDepthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NetworkStatusResponseType, _p_FIX__NetworkStatusResponseTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoComplexEvents, _p_FIX__NoComplexEventsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EventType, _p_FIX__EventTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ComplexEventType, _p_FIX__ComplexEventTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocAccountType, _p_FIX__AllocAccountTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RespondentType, _p_FIX__RespondentTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AccountType, _p_FIX__AccountTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AdjustmentType, _p_FIX__AdjustmentTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeEventType, _p_FIX__DerivativeEventTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoEvents, _p_FIX__NoEventsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDerivativeEvents, _p_FIX__NoDerivativeEventsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementType, _p_FIX__UnderlyingSettlementTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoAltMDSource, _p_FIX__NoAltMDSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AcctIDSource, _p_FIX__AcctIDSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrderHandlingInstSource, _p_FIX__OrderHandlingInstSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocAcctIDSource, _p_FIX__AllocAcctIDSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityListTypeSource, _p_FIX__SecurityListTypeSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RateSource, _p_FIX__RateSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DeskTypeSource, _p_FIX__DeskTypeSourceTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BidType, _p_FIX__BidTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDates, _p_FIX__NoDatesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StrategyParameterType, _p_FIX__StrategyParameterTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OwnerType, _p_FIX__OwnerTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSides, _p_FIX__NoSidesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeNTPositionLimit, _p_FIX__DerivativeNTPositionLimitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDOriginType, _p_FIX__MDOriginTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PositionLimit, _p_FIX__PositionLimitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NTPositionLimit, _p_FIX__NTPositionLimitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CrossPrioritization, _p_FIX__CrossPrioritizationTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativePositionLimit, _p_FIX__DerivativePositionLimitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoRejQuotes, _p_FIX__TotNoRejQuotesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoCxldQuotes, _p_FIX__TotNoCxldQuotesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocHandlInst, _p_FIX__AllocHandlInstTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMDFeedTypes, _p_FIX__NoMDFeedTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoAccQuotes, _p_FIX__TotNoAccQuotesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoBidDescriptors, _p_FIX__NoBidDescriptorsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTrdRepIndicators, _p_FIX__NoTrdRepIndicatorsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStatsIndicators, _p_FIX__NoStatsIndicatorsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLegStipulations, _p_FIX__NoLegStipulationsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStipulations, _p_FIX__NoStipulationsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDistribInsts, _p_FIX__NoDistribInstsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__OrderDelayUnit, _p_FIX__OrderDelayUnitTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LiquidityNumSecurities, _p_FIX__LiquidityNumSecuritiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotalNumSecurities, _p_FIX__TotalNumSecuritiesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EndSeqNo, _p_FIX__EndSeqNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRpts, _p_FIX__NoRptsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityTradingEvent, _p_FIX__SecurityTradingEventTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdSubType, _p_FIX__TrdSubTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ProgRptReqs, _p_FIX__ProgRptReqsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotalNumSecurityTypes, _p_FIX__TotalNumSecurityTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoMDEntryTypes, _p_FIX__NoMDEntryTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ProgPeriodInterval, _p_FIX__ProgPeriodIntervalTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoSecurityTypes, _p_FIX__TotNoSecurityTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoSecurityTypes, _p_FIX__NoSecurityTypesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ContAmtType, _p_FIX__ContAmtTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAsgnTransType, _p_FIX__CollAsgnTransTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeReportTransType, _p_FIX__TradeReportTransTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassActionResponse, _p_FIX__MassActionResponseTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ConfirmTransType, _p_FIX__ConfirmTransTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosTransType, _p_FIX__PosTransTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BidDescriptorType, _p_FIX__BidDescriptorTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TaxAdvantageType, _p_FIX__TaxAdvantageTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RootPartySubIDType, _p_FIX__RootPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartySubIDType, _p_FIX__DerivativeInstrumentPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested2PartySubIDType, _p_FIX__Nested2PartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartySubIDType, _p_FIX__UndlyInstrumentPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartySubIDType, _p_FIX__UnderlyingInstrumentPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NestedPartySubIDType, _p_FIX__NestedPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested3PartySubIDType, _p_FIX__Nested3PartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlPartySubIDType, _p_FIX__SettlPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__Nested4PartySubIDType, _p_FIX__Nested4PartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoDlvyInst, _p_FIX__NoDlvyInstTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__InstrumentPartySubIDType, _p_FIX__InstrumentPartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PartySubIDType, _p_FIX__PartySubIDTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedTextLen, _p_FIX__EncodedTextLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedAllocTextLen, _p_FIX__EncodedAllocTextLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedListStatusTextLen, _p_FIX__EncodedListStatusTextLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoQuoteQualifiers, _p_FIX__NoQuoteQualifiersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoIOIQualifiers, _p_FIX__NoIOIQualifiersTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MDEntryPositionNo, _p_FIX__MDEntryPositionNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BeginSeqNo, _p_FIX__BeginSeqNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassStatusReqType, _p_FIX__MassStatusReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosReqType, _p_FIX__PosReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__AllocIntermedReqType, _p_FIX__AllocIntermedReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StreamAsgnReqType, _p_FIX__StreamAsgnReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplReqType, _p_FIX__ApplReqTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__EncodedSubjectLen, _p_FIX__EncodedSubjectLenTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DeliveryType, _p_FIX__DeliveryTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SettlDeliveryType, _p_FIX__SettlDeliveryTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NewsCategory, _p_FIX__NewsCategoryTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TrdType, _p_FIX__TrdTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecondaryTrdType, _p_FIX__SecondaryTrdTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoRelatedSym, _p_FIX__TotNoRelatedSymTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRelatedSym, _p_FIX__NoRelatedSymTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ExpirationCycle, _p_FIX__ExpirationCycleTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplQueueMax, _p_FIX__ApplQueueMaxTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollAction, _p_FIX__CollActionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosMaintAction, _p_FIX__PosMaintActionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NewsRefType, _p_FIX__NewsRefTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplQueueAction, _p_FIX__ApplQueueActionTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__LinesOfText, _p_FIX__LinesOfTextTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MassActionScope, _p_FIX__MassActionScopeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoLinesOfText, _p_FIX__NoLinesOfTextTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DiscretionScope, _p_FIX__DiscretionScopeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrAttribType, _p_FIX__DerivativeInstrAttribTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NestedInstrAttribType, _p_FIX__NestedInstrAttribTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__InstrAttribType, _p_FIX__InstrAttribTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NetGrossInd, _p_FIX__NetGrossIndTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoTickRules, _p_FIX__NoTickRulesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoOfSecSizes, _p_FIX__NoOfSecSizesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__StreamAsgnType, _p_FIX__StreamAsgnTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoStrikes, _p_FIX__NoStrikesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TotNoStrikes, _p_FIX__TotNoStrikesTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefTagID, _p_FIX__RefTagIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoExecs, _p_FIX__NoExecsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SideMultiLegReportingType, _p_FIX__SideMultiLegReportingTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RoutingType, _p_FIX__RoutingTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BookingType, _p_FIX__BookingTypeTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NumDaysInterest, _p_FIX__NumDaysInterestTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SecurityRequestResult, _p_FIX__SecurityRequestResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosMaintResult, _p_FIX__PosMaintResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__TradeRequestResult, _p_FIX__TradeRequestResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__PosReqResult, _p_FIX__PosReqResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__CollInquiryResult, _p_FIX__CollInquiryResultTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RawDataLength, _p_FIX__RawDataLengthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__BodyLength, _p_FIX__BodyLengthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__SignatureLength, _p_FIX__SignatureLengthTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ApplExtID, _p_FIX__ApplExtIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__DefaultApplExtID, _p_FIX__DefaultApplExtIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__RefApplExtID, _p_FIX__RefApplExtIDTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoRoutingIDs, _p_FIX__NoRoutingIDsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NewSeqNo, _p_FIX__NewSeqNoTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__MaturityMonthYearIncrementUnits, _p_FIX__MaturityMonthYearIncrementUnitsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__HaltReasonInt, _p_FIX__HaltReasonIntTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__NoUnderlyingStips, _p_FIX__NoUnderlyingStipsTo_p_FIX__IntField, 0, 0},  {&_swigt__p_FIX__ConfirmType, _p_FIX__ConfirmTypeTo_p_FIX__IntField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InterestAccrualDate[] = {  {&_swigt__p_FIX__InterestAccrualDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InterestAtMaturity[] = {  {&_swigt__p_FIX__InterestAtMaturity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InvalidMessage[] = {  {&_swigt__p_FIX__InvalidMessage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InvalidMessageType[] = {  {&_swigt__p_FIX__InvalidMessageType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InvalidTagNumber[] = {  {&_swigt__p_FIX__InvalidTagNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__InvestorCountryOfResidence[] = {  {&_swigt__p_FIX__InvestorCountryOfResidence, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__IssueDate[] = {  {&_swigt__p_FIX__IssueDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Issuer[] = {  {&_swigt__p_FIX__Issuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LANGUAGE[] = {  {&_swigt__p_FIX__LANGUAGE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LENGTH[] = {  {&_swigt__p_FIX__LENGTH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LOCALMKTDATE[] = {  {&_swigt__p_FIX__LOCALMKTDATE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LanguageCode[] = {  {&_swigt__p_FIX__LanguageCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastCapacity[] = {  {&_swigt__p_FIX__LastCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastForwardPoints[] = {  {&_swigt__p_FIX__LastForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastForwardPoints2[] = {  {&_swigt__p_FIX__LastForwardPoints2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastFragment[] = {  {&_swigt__p_FIX__LastFragment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastLiquidityInd[] = {  {&_swigt__p_FIX__LastLiquidityInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastMkt[] = {  {&_swigt__p_FIX__LastMkt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastMsgSeqNumProcessed[] = {  {&_swigt__p_FIX__LastMsgSeqNumProcessed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastNetworkResponseID[] = {  {&_swigt__p_FIX__LastNetworkResponseID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastParPx[] = {  {&_swigt__p_FIX__LastParPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastPx[] = {  {&_swigt__p_FIX__LastPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastQty[] = {  {&_swigt__p_FIX__LastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastRptRequested[] = {  {&_swigt__p_FIX__LastRptRequested, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastShares[] = {  {&_swigt__p_FIX__LastShares, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastSpotRate[] = {  {&_swigt__p_FIX__LastSpotRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastSwapPoints[] = {  {&_swigt__p_FIX__LastSwapPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LastUpdateTime[] = {  {&_swigt__p_FIX__LastUpdateTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LateIndicator[] = {  {&_swigt__p_FIX__LateIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LeavesQty[] = {  {&_swigt__p_FIX__LeavesQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocAccount[] = {  {&_swigt__p_FIX__LegAllocAccount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocAcctIDSource[] = {  {&_swigt__p_FIX__LegAllocAcctIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocID[] = {  {&_swigt__p_FIX__LegAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocQty[] = {  {&_swigt__p_FIX__LegAllocQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegAllocSettlCurrency[] = {  {&_swigt__p_FIX__LegAllocSettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkCurveCurrency[] = {  {&_swigt__p_FIX__LegBenchmarkCurveCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkCurveName[] = {  {&_swigt__p_FIX__LegBenchmarkCurveName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkCurvePoint[] = {  {&_swigt__p_FIX__LegBenchmarkCurvePoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkPrice[] = {  {&_swigt__p_FIX__LegBenchmarkPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBenchmarkPriceType[] = {  {&_swigt__p_FIX__LegBenchmarkPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBidForwardPoints[] = {  {&_swigt__p_FIX__LegBidForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegBidPx[] = {  {&_swigt__p_FIX__LegBidPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCFICode[] = {  {&_swigt__p_FIX__LegCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCalculatedCcyLastQty[] = {  {&_swigt__p_FIX__LegCalculatedCcyLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegContractMultiplier[] = {  {&_swigt__p_FIX__LegContractMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegContractMultiplierUnit[] = {  {&_swigt__p_FIX__LegContractMultiplierUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegContractSettlMonth[] = {  {&_swigt__p_FIX__LegContractSettlMonth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCountryOfIssue[] = {  {&_swigt__p_FIX__LegCountryOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCouponPaymentDate[] = {  {&_swigt__p_FIX__LegCouponPaymentDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCouponRate[] = {  {&_swigt__p_FIX__LegCouponRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCoveredOrUncovered[] = {  {&_swigt__p_FIX__LegCoveredOrUncovered, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCreditRating[] = {  {&_swigt__p_FIX__LegCreditRating, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCurrency[] = {  {&_swigt__p_FIX__LegCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegCurrencyRatio[] = {  {&_swigt__p_FIX__LegCurrencyRatio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegDatedDate[] = {  {&_swigt__p_FIX__LegDatedDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegDividendYield[] = {  {&_swigt__p_FIX__LegDividendYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegExecInst[] = {  {&_swigt__p_FIX__LegExecInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegExerciseStyle[] = {  {&_swigt__p_FIX__LegExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegFactor[] = {  {&_swigt__p_FIX__LegFactor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegFlowScheduleType[] = {  {&_swigt__p_FIX__LegFlowScheduleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegFutSettDate[] = {  {&_swigt__p_FIX__LegFutSettDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegGrossTradeAmt[] = {  {&_swigt__p_FIX__LegGrossTradeAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegIOIQty[] = {  {&_swigt__p_FIX__LegIOIQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegIndividualAllocID[] = {  {&_swigt__p_FIX__LegIndividualAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegInstrRegistry[] = {  {&_swigt__p_FIX__LegInstrRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegInterestAccrualDate[] = {  {&_swigt__p_FIX__LegInterestAccrualDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegIssueDate[] = {  {&_swigt__p_FIX__LegIssueDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegIssuer[] = {  {&_swigt__p_FIX__LegIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegLastForwardPoints[] = {  {&_swigt__p_FIX__LegLastForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegLastPx[] = {  {&_swigt__p_FIX__LegLastPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegLastQty[] = {  {&_swigt__p_FIX__LegLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegLocaleOfIssue[] = {  {&_swigt__p_FIX__LegLocaleOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegMaturityDate[] = {  {&_swigt__p_FIX__LegMaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegMaturityMonthYear[] = {  {&_swigt__p_FIX__LegMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegMaturityTime[] = {  {&_swigt__p_FIX__LegMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegNumber[] = {  {&_swigt__p_FIX__LegNumber, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOfferForwardPoints[] = {  {&_swigt__p_FIX__LegOfferForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOfferPx[] = {  {&_swigt__p_FIX__LegOfferPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOptAttribute[] = {  {&_swigt__p_FIX__LegOptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOptionRatio[] = {  {&_swigt__p_FIX__LegOptionRatio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegOrderQty[] = {  {&_swigt__p_FIX__LegOrderQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPool[] = {  {&_swigt__p_FIX__LegPool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPositionEffect[] = {  {&_swigt__p_FIX__LegPositionEffect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPrice[] = {  {&_swigt__p_FIX__LegPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPriceType[] = {  {&_swigt__p_FIX__LegPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPriceUnitOfMeasure[] = {  {&_swigt__p_FIX__LegPriceUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPriceUnitOfMeasureQty[] = {  {&_swigt__p_FIX__LegPriceUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegProduct[] = {  {&_swigt__p_FIX__LegProduct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegPutOrCall[] = {  {&_swigt__p_FIX__LegPutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegQty[] = {  {&_swigt__p_FIX__LegQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRatioQty[] = {  {&_swigt__p_FIX__LegRatioQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRedemptionDate[] = {  {&_swigt__p_FIX__LegRedemptionDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRefID[] = {  {&_swigt__p_FIX__LegRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRepoCollateralSecurityType[] = {  {&_swigt__p_FIX__LegRepoCollateralSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegReportID[] = {  {&_swigt__p_FIX__LegReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRepurchaseRate[] = {  {&_swigt__p_FIX__LegRepurchaseRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegRepurchaseTerm[] = {  {&_swigt__p_FIX__LegRepurchaseTerm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityAltID[] = {  {&_swigt__p_FIX__LegSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityAltIDSource[] = {  {&_swigt__p_FIX__LegSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityDesc[] = {  {&_swigt__p_FIX__LegSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityExchange[] = {  {&_swigt__p_FIX__LegSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityID[] = {  {&_swigt__p_FIX__LegSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityIDSource[] = {  {&_swigt__p_FIX__LegSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecuritySubType[] = {  {&_swigt__p_FIX__LegSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSecurityType[] = {  {&_swigt__p_FIX__LegSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSettlCurrency[] = {  {&_swigt__p_FIX__LegSettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSettlDate[] = {  {&_swigt__p_FIX__LegSettlDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSettlType[] = {  {&_swigt__p_FIX__LegSettlType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSettlmntTyp[] = {  {&_swigt__p_FIX__LegSettlmntTyp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSide[] = {  {&_swigt__p_FIX__LegSide, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStateOrProvinceOfIssue[] = {  {&_swigt__p_FIX__LegStateOrProvinceOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStipulationType[] = {  {&_swigt__p_FIX__LegStipulationType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStipulationValue[] = {  {&_swigt__p_FIX__LegStipulationValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStrikeCurrency[] = {  {&_swigt__p_FIX__LegStrikeCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegStrikePrice[] = {  {&_swigt__p_FIX__LegStrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSwapType[] = {  {&_swigt__p_FIX__LegSwapType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSymbol[] = {  {&_swigt__p_FIX__LegSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegSymbolSfx[] = {  {&_swigt__p_FIX__LegSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegTimeUnit[] = {  {&_swigt__p_FIX__LegTimeUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegUnitOfMeasure[] = {  {&_swigt__p_FIX__LegUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegUnitOfMeasureQty[] = {  {&_swigt__p_FIX__LegUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegVolatility[] = {  {&_swigt__p_FIX__LegVolatility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LegalConfirm[] = {  {&_swigt__p_FIX__LegalConfirm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LinesOfText[] = {  {&_swigt__p_FIX__LinesOfText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityIndType[] = {  {&_swigt__p_FIX__LiquidityIndType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityNumSecurities[] = {  {&_swigt__p_FIX__LiquidityNumSecurities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityPctHigh[] = {  {&_swigt__p_FIX__LiquidityPctHigh, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityPctLow[] = {  {&_swigt__p_FIX__LiquidityPctLow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LiquidityValue[] = {  {&_swigt__p_FIX__LiquidityValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListExecInst[] = {  {&_swigt__p_FIX__ListExecInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListExecInstType[] = {  {&_swigt__p_FIX__ListExecInstType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListID[] = {  {&_swigt__p_FIX__ListID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListMethod[] = {  {&_swigt__p_FIX__ListMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListName[] = {  {&_swigt__p_FIX__ListName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListNoOrds[] = {  {&_swigt__p_FIX__ListNoOrds, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListOrderStatus[] = {  {&_swigt__p_FIX__ListOrderStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListRejectReason[] = {  {&_swigt__p_FIX__ListRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListSeqNo[] = {  {&_swigt__p_FIX__ListSeqNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListStatusText[] = {  {&_swigt__p_FIX__ListStatusText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListStatusType[] = {  {&_swigt__p_FIX__ListStatusType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ListUpdateAction[] = {  {&_swigt__p_FIX__ListUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LocaleOfIssue[] = {  {&_swigt__p_FIX__LocaleOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LocateReqd[] = {  {&_swigt__p_FIX__LocateReqd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LocationID[] = {  {&_swigt__p_FIX__LocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Log[] = {  {&_swigt__p_FIX__NullLog, _p_FIX__NullLogTo_p_FIX__Log, 0, 0},  {&_swigt__p_FIX__Log, 0, 0, 0},  {&_swigt__p_FIX__FileLog, _p_FIX__FileLogTo_p_FIX__Log, 0, 0},  {&_swigt__p_FIX__ScreenLog, _p_FIX__ScreenLogTo_p_FIX__Log, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LogFactory[] = {  {&_swigt__p_FIX__LogFactory, 0, 0, 0},  {&_swigt__p_FIX__ScreenLogFactory, _p_FIX__ScreenLogFactoryTo_p_FIX__LogFactory, 0, 0},  {&_swigt__p_FIX__FileLogFactory, _p_FIX__FileLogFactoryTo_p_FIX__LogFactory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LongQty[] = {  {&_swigt__p_FIX__LongQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LotType[] = {  {&_swigt__p_FIX__LotType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LowLimitPrice[] = {  {&_swigt__p_FIX__LowLimitPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__LowPx[] = {  {&_swigt__p_FIX__LowPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDBookType[] = {  {&_swigt__p_FIX__MDBookType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryBuyer[] = {  {&_swigt__p_FIX__MDEntryBuyer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryDate[] = {  {&_swigt__p_FIX__MDEntryDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryForwardPoints[] = {  {&_swigt__p_FIX__MDEntryForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryID[] = {  {&_swigt__p_FIX__MDEntryID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryOriginator[] = {  {&_swigt__p_FIX__MDEntryOriginator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryPositionNo[] = {  {&_swigt__p_FIX__MDEntryPositionNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryPx[] = {  {&_swigt__p_FIX__MDEntryPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryRefID[] = {  {&_swigt__p_FIX__MDEntryRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntrySeller[] = {  {&_swigt__p_FIX__MDEntrySeller, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntrySize[] = {  {&_swigt__p_FIX__MDEntrySize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntrySpotRate[] = {  {&_swigt__p_FIX__MDEntrySpotRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryTime[] = {  {&_swigt__p_FIX__MDEntryTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDEntryType[] = {  {&_swigt__p_FIX__MDEntryType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDFeedType[] = {  {&_swigt__p_FIX__MDFeedType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDImplicitDelete[] = {  {&_swigt__p_FIX__MDImplicitDelete, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDMkt[] = {  {&_swigt__p_FIX__MDMkt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDOriginType[] = {  {&_swigt__p_FIX__MDOriginType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDPriceLevel[] = {  {&_swigt__p_FIX__MDPriceLevel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDQuoteType[] = {  {&_swigt__p_FIX__MDQuoteType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDReportID[] = {  {&_swigt__p_FIX__MDReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDReqID[] = {  {&_swigt__p_FIX__MDReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDReqRejReason[] = {  {&_swigt__p_FIX__MDReqRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDSecSize[] = {  {&_swigt__p_FIX__MDSecSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDSecSizeType[] = {  {&_swigt__p_FIX__MDSecSizeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDStreamID[] = {  {&_swigt__p_FIX__MDStreamID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDSubBookType[] = {  {&_swigt__p_FIX__MDSubBookType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDUpdateAction[] = {  {&_swigt__p_FIX__MDUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MDUpdateType[] = {  {&_swigt__p_FIX__MDUpdateType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MONTHYEAR[] = {  {&_swigt__p_FIX__MONTHYEAR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MULTIPLECHARVALUE[] = {  {&_swigt__p_FIX__MULTIPLECHARVALUE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MULTIPLESTRINGVALUE[] = {  {&_swigt__p_FIX__MULTIPLESTRINGVALUE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MULTIPLEVALUESTRING[] = {  {&_swigt__p_FIX__MULTIPLEVALUESTRING, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MailingDtls[] = {  {&_swigt__p_FIX__MailingDtls, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MailingInst[] = {  {&_swigt__p_FIX__MailingInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ManualOrderIndicator[] = {  {&_swigt__p_FIX__ManualOrderIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarginExcess[] = {  {&_swigt__p_FIX__MarginExcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarginRatio[] = {  {&_swigt__p_FIX__MarginRatio, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketDepth[] = {  {&_swigt__p_FIX__MarketDepth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketID[] = {  {&_swigt__p_FIX__MarketID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketReportID[] = {  {&_swigt__p_FIX__MarketReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketReqID[] = {  {&_swigt__p_FIX__MarketReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketSegmentDesc[] = {  {&_swigt__p_FIX__MarketSegmentDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketSegmentID[] = {  {&_swigt__p_FIX__MarketSegmentID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MarketUpdateAction[] = {  {&_swigt__p_FIX__MarketUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionRejectReason[] = {  {&_swigt__p_FIX__MassActionRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionReportID[] = {  {&_swigt__p_FIX__MassActionReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionResponse[] = {  {&_swigt__p_FIX__MassActionResponse, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionScope[] = {  {&_swigt__p_FIX__MassActionScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassActionType[] = {  {&_swigt__p_FIX__MassActionType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassCancelRejectReason[] = {  {&_swigt__p_FIX__MassCancelRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassCancelRequestType[] = {  {&_swigt__p_FIX__MassCancelRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassCancelResponse[] = {  {&_swigt__p_FIX__MassCancelResponse, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassStatusReqID[] = {  {&_swigt__p_FIX__MassStatusReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MassStatusReqType[] = {  {&_swigt__p_FIX__MassStatusReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MatchAlgorithm[] = {  {&_swigt__p_FIX__MatchAlgorithm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MatchIncrement[] = {  {&_swigt__p_FIX__MatchIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MatchStatus[] = {  {&_swigt__p_FIX__MatchStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MatchType[] = {  {&_swigt__p_FIX__MatchType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityDate[] = {  {&_swigt__p_FIX__MaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityDay[] = {  {&_swigt__p_FIX__MaturityDay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityMonthYear[] = {  {&_swigt__p_FIX__MaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityMonthYearFormat[] = {  {&_swigt__p_FIX__MaturityMonthYearFormat, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityMonthYearIncrement[] = {  {&_swigt__p_FIX__MaturityMonthYearIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityMonthYearIncrementUnits[] = {  {&_swigt__p_FIX__MaturityMonthYearIncrementUnits, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityNetMoney[] = {  {&_swigt__p_FIX__MaturityNetMoney, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityRuleID[] = {  {&_swigt__p_FIX__MaturityRuleID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaturityTime[] = {  {&_swigt__p_FIX__MaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxFloor[] = {  {&_swigt__p_FIX__MaxFloor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxMessageSize[] = {  {&_swigt__p_FIX__MaxMessageSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxPriceLevels[] = {  {&_swigt__p_FIX__MaxPriceLevels, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxPriceVariation[] = {  {&_swigt__p_FIX__MaxPriceVariation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxShow[] = {  {&_swigt__p_FIX__MaxShow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MaxTradeVol[] = {  {&_swigt__p_FIX__MaxTradeVol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MemoryStore[] = {  {&_swigt__p_FIX__MemoryStore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MemoryStoreFactory[] = {  {&_swigt__p_FIX__MemoryStoreFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Message[] = {  {&_swigt__p_FIX__Message, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageEncoding[] = {  {&_swigt__p_FIX__MessageEncoding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageEventSource[] = {  {&_swigt__p_FIX__MessageEventSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageParseError[] = {  {&_swigt__p_FIX__MessageParseError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageStore[] = {  {&_swigt__p_FIX__MemoryStore, _p_FIX__MemoryStoreTo_p_FIX__MessageStore, 0, 0},  {&_swigt__p_FIX__MessageStore, 0, 0, 0},  {&_swigt__p_FIX__FileStore, _p_FIX__FileStoreTo_p_FIX__MessageStore, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageStoreExceptionWrapper[] = {  {&_swigt__p_FIX__MessageStoreExceptionWrapper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageStoreFactory[] = {  {&_swigt__p_FIX__MessageStoreFactory, 0, 0, 0},  {&_swigt__p_FIX__MemoryStoreFactory, _p_FIX__MemoryStoreFactoryTo_p_FIX__MessageStoreFactory, 0, 0},  {&_swigt__p_FIX__FileStoreFactory, _p_FIX__FileStoreFactoryTo_p_FIX__MessageStoreFactory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MessageStoreFactoryExceptionWrapper[] = {  {&_swigt__p_FIX__MessageStoreFactoryExceptionWrapper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MidPx[] = {  {&_swigt__p_FIX__MidPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MidYield[] = {  {&_swigt__p_FIX__MidYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinBidSize[] = {  {&_swigt__p_FIX__MinBidSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinLotSize[] = {  {&_swigt__p_FIX__MinLotSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinOfferSize[] = {  {&_swigt__p_FIX__MinOfferSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinPriceIncrement[] = {  {&_swigt__p_FIX__MinPriceIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinPriceIncrementAmount[] = {  {&_swigt__p_FIX__MinPriceIncrementAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinQty[] = {  {&_swigt__p_FIX__MinQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MinTradeVol[] = {  {&_swigt__p_FIX__MinTradeVol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MiscFeeAmt[] = {  {&_swigt__p_FIX__MiscFeeAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MiscFeeBasis[] = {  {&_swigt__p_FIX__MiscFeeBasis, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MiscFeeCurr[] = {  {&_swigt__p_FIX__MiscFeeCurr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MiscFeeType[] = {  {&_swigt__p_FIX__MiscFeeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MktBidPx[] = {  {&_swigt__p_FIX__MktBidPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MktOfferPx[] = {  {&_swigt__p_FIX__MktOfferPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ModelType[] = {  {&_swigt__p_FIX__ModelType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MoneyLaunderingStatus[] = {  {&_swigt__p_FIX__MoneyLaunderingStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MsgDirection[] = {  {&_swigt__p_FIX__MsgDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MsgSeqNum[] = {  {&_swigt__p_FIX__MsgSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MsgType[] = {  {&_swigt__p_FIX__MsgType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MultiLegReportingType[] = {  {&_swigt__p_FIX__MultiLegReportingType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MultiLegRptTypeReq[] = {  {&_swigt__p_FIX__MultiLegRptTypeReq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MultilegModel[] = {  {&_swigt__p_FIX__MultilegModel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__MultilegPriceMethod[] = {  {&_swigt__p_FIX__MultilegPriceMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NTPositionLimit[] = {  {&_swigt__p_FIX__NTPositionLimit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NUMINGROUP[] = {  {&_swigt__p_FIX__NUMINGROUP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartyID[] = {  {&_swigt__p_FIX__Nested2PartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartyIDSource[] = {  {&_swigt__p_FIX__Nested2PartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartyRole[] = {  {&_swigt__p_FIX__Nested2PartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartySubID[] = {  {&_swigt__p_FIX__Nested2PartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested2PartySubIDType[] = {  {&_swigt__p_FIX__Nested2PartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartyID[] = {  {&_swigt__p_FIX__Nested3PartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartyIDSource[] = {  {&_swigt__p_FIX__Nested3PartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartyRole[] = {  {&_swigt__p_FIX__Nested3PartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartySubID[] = {  {&_swigt__p_FIX__Nested3PartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested3PartySubIDType[] = {  {&_swigt__p_FIX__Nested3PartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartyID[] = {  {&_swigt__p_FIX__Nested4PartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartyIDSource[] = {  {&_swigt__p_FIX__Nested4PartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartyRole[] = {  {&_swigt__p_FIX__Nested4PartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartySubID[] = {  {&_swigt__p_FIX__Nested4PartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Nested4PartySubIDType[] = {  {&_swigt__p_FIX__Nested4PartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedInstrAttribType[] = {  {&_swigt__p_FIX__NestedInstrAttribType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedInstrAttribValue[] = {  {&_swigt__p_FIX__NestedInstrAttribValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartyID[] = {  {&_swigt__p_FIX__NestedPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartyIDSource[] = {  {&_swigt__p_FIX__NestedPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartyRole[] = {  {&_swigt__p_FIX__NestedPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartySubID[] = {  {&_swigt__p_FIX__NestedPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NestedPartySubIDType[] = {  {&_swigt__p_FIX__NestedPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetChgPrevDay[] = {  {&_swigt__p_FIX__NetChgPrevDay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetGrossInd[] = {  {&_swigt__p_FIX__NetGrossInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetMoney[] = {  {&_swigt__p_FIX__NetMoney, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetworkRequestID[] = {  {&_swigt__p_FIX__NetworkRequestID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetworkRequestType[] = {  {&_swigt__p_FIX__NetworkRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetworkResponseID[] = {  {&_swigt__p_FIX__NetworkResponseID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NetworkStatusResponseType[] = {  {&_swigt__p_FIX__NetworkStatusResponseType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewPassword[] = {  {&_swigt__p_FIX__NewPassword, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewSeqNo[] = {  {&_swigt__p_FIX__NewSeqNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewsCategory[] = {  {&_swigt__p_FIX__NewsCategory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewsID[] = {  {&_swigt__p_FIX__NewsID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewsRefID[] = {  {&_swigt__p_FIX__NewsRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NewsRefType[] = {  {&_swigt__p_FIX__NewsRefType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NextExpectedMsgSeqNum[] = {  {&_swigt__p_FIX__NextExpectedMsgSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoAffectedOrders[] = {  {&_swigt__p_FIX__NoAffectedOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoAllocs[] = {  {&_swigt__p_FIX__NoAllocs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoAltMDSource[] = {  {&_swigt__p_FIX__NoAltMDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoApplIDs[] = {  {&_swigt__p_FIX__NoApplIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoAsgnReqs[] = {  {&_swigt__p_FIX__NoAsgnReqs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoBidComponents[] = {  {&_swigt__p_FIX__NoBidComponents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoBidDescriptors[] = {  {&_swigt__p_FIX__NoBidDescriptors, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoCapacities[] = {  {&_swigt__p_FIX__NoCapacities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoClearingInstructions[] = {  {&_swigt__p_FIX__NoClearingInstructions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoCollInquiryQualifier[] = {  {&_swigt__p_FIX__NoCollInquiryQualifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoCompIDs[] = {  {&_swigt__p_FIX__NoCompIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoComplexEventDates[] = {  {&_swigt__p_FIX__NoComplexEventDates, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoComplexEventTimes[] = {  {&_swigt__p_FIX__NoComplexEventTimes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoComplexEvents[] = {  {&_swigt__p_FIX__NoComplexEvents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoContAmts[] = {  {&_swigt__p_FIX__NoContAmts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoContraBrokers[] = {  {&_swigt__p_FIX__NoContraBrokers, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDates[] = {  {&_swigt__p_FIX__NoDates, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeEvents[] = {  {&_swigt__p_FIX__NoDerivativeEvents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeInstrAttrib[] = {  {&_swigt__p_FIX__NoDerivativeInstrAttrib, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeInstrumentParties[] = {  {&_swigt__p_FIX__NoDerivativeInstrumentParties, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeInstrumentPartySubIDs[] = {  {&_swigt__p_FIX__NoDerivativeInstrumentPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDerivativeSecurityAltID[] = {  {&_swigt__p_FIX__NoDerivativeSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDistribInsts[] = {  {&_swigt__p_FIX__NoDistribInsts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoDlvyInst[] = {  {&_swigt__p_FIX__NoDlvyInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoEvents[] = {  {&_swigt__p_FIX__NoEvents, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoExecInstRules[] = {  {&_swigt__p_FIX__NoExecInstRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoExecs[] = {  {&_swigt__p_FIX__NoExecs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoExpiration[] = {  {&_swigt__p_FIX__NoExpiration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoFills[] = {  {&_swigt__p_FIX__NoFills, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoHops[] = {  {&_swigt__p_FIX__NoHops, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoIOIQualifiers[] = {  {&_swigt__p_FIX__NoIOIQualifiers, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoInstrAttrib[] = {  {&_swigt__p_FIX__NoInstrAttrib, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoInstrumentParties[] = {  {&_swigt__p_FIX__NoInstrumentParties, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoInstrumentPartySubIDs[] = {  {&_swigt__p_FIX__NoInstrumentPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLegAllocs[] = {  {&_swigt__p_FIX__NoLegAllocs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLegSecurityAltID[] = {  {&_swigt__p_FIX__NoLegSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLegStipulations[] = {  {&_swigt__p_FIX__NoLegStipulations, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLegs[] = {  {&_swigt__p_FIX__NoLegs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLinesOfText[] = {  {&_swigt__p_FIX__NoLinesOfText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoLotTypeRules[] = {  {&_swigt__p_FIX__NoLotTypeRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMDEntries[] = {  {&_swigt__p_FIX__NoMDEntries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMDEntryTypes[] = {  {&_swigt__p_FIX__NoMDEntryTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMDFeedTypes[] = {  {&_swigt__p_FIX__NoMDFeedTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMarketSegments[] = {  {&_swigt__p_FIX__NoMarketSegments, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMatchRules[] = {  {&_swigt__p_FIX__NoMatchRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMaturityRules[] = {  {&_swigt__p_FIX__NoMaturityRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMiscFees[] = {  {&_swigt__p_FIX__NoMiscFees, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoMsgTypes[] = {  {&_swigt__p_FIX__NoMsgTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested2PartyIDs[] = {  {&_swigt__p_FIX__NoNested2PartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested2PartySubIDs[] = {  {&_swigt__p_FIX__NoNested2PartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested3PartyIDs[] = {  {&_swigt__p_FIX__NoNested3PartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested3PartySubIDs[] = {  {&_swigt__p_FIX__NoNested3PartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested4PartyIDs[] = {  {&_swigt__p_FIX__NoNested4PartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNested4PartySubIDs[] = {  {&_swigt__p_FIX__NoNested4PartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNestedInstrAttrib[] = {  {&_swigt__p_FIX__NoNestedInstrAttrib, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNestedPartyIDs[] = {  {&_swigt__p_FIX__NoNestedPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNestedPartySubIDs[] = {  {&_swigt__p_FIX__NoNestedPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNewsRefIDs[] = {  {&_swigt__p_FIX__NoNewsRefIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoNotAffectedOrders[] = {  {&_swigt__p_FIX__NoNotAffectedOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoOfLegUnderlyings[] = {  {&_swigt__p_FIX__NoOfLegUnderlyings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoOfSecSizes[] = {  {&_swigt__p_FIX__NoOfSecSizes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoOrdTypeRules[] = {  {&_swigt__p_FIX__NoOrdTypeRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoOrders[] = {  {&_swigt__p_FIX__NoOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPartyIDs[] = {  {&_swigt__p_FIX__NoPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPartySubIDs[] = {  {&_swigt__p_FIX__NoPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPosAmt[] = {  {&_swigt__p_FIX__NoPosAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoPositions[] = {  {&_swigt__p_FIX__NoPositions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoQuoteEntries[] = {  {&_swigt__p_FIX__NoQuoteEntries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoQuoteQualifiers[] = {  {&_swigt__p_FIX__NoQuoteQualifiers, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoQuoteSets[] = {  {&_swigt__p_FIX__NoQuoteSets, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRateSources[] = {  {&_swigt__p_FIX__NoRateSources, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRegistDtls[] = {  {&_swigt__p_FIX__NoRegistDtls, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRelatedSym[] = {  {&_swigt__p_FIX__NoRelatedSym, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRootPartyIDs[] = {  {&_swigt__p_FIX__NoRootPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRootPartySubIDs[] = {  {&_swigt__p_FIX__NoRootPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRoutingIDs[] = {  {&_swigt__p_FIX__NoRoutingIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoRpts[] = {  {&_swigt__p_FIX__NoRpts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSecurityAltID[] = {  {&_swigt__p_FIX__NoSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSecurityTypes[] = {  {&_swigt__p_FIX__NoSecurityTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlDetails[] = {  {&_swigt__p_FIX__NoSettlDetails, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlInst[] = {  {&_swigt__p_FIX__NoSettlInst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlOblig[] = {  {&_swigt__p_FIX__NoSettlOblig, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlPartyIDs[] = {  {&_swigt__p_FIX__NoSettlPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSettlPartySubIDs[] = {  {&_swigt__p_FIX__NoSettlPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSideTrdRegTS[] = {  {&_swigt__p_FIX__NoSideTrdRegTS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoSides[] = {  {&_swigt__p_FIX__NoSides, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStatsIndicators[] = {  {&_swigt__p_FIX__NoStatsIndicators, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStipulations[] = {  {&_swigt__p_FIX__NoStipulations, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStrategyParameters[] = {  {&_swigt__p_FIX__NoStrategyParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStrikeRules[] = {  {&_swigt__p_FIX__NoStrikeRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoStrikes[] = {  {&_swigt__p_FIX__NoStrikes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTagValue[] = {  {&_swigt__p_FIX__NoTagValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTargetPartyIDs[] = {  {&_swigt__p_FIX__NoTargetPartyIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTickRules[] = {  {&_swigt__p_FIX__NoTickRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTimeInForceRules[] = {  {&_swigt__p_FIX__NoTimeInForceRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTrades[] = {  {&_swigt__p_FIX__NoTrades, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTradingSessionRules[] = {  {&_swigt__p_FIX__NoTradingSessionRules, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTradingSessions[] = {  {&_swigt__p_FIX__NoTradingSessions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTrdRegTimestamps[] = {  {&_swigt__p_FIX__NoTrdRegTimestamps, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoTrdRepIndicators[] = {  {&_swigt__p_FIX__NoTrdRepIndicators, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyingAmounts[] = {  {&_swigt__p_FIX__NoUnderlyingAmounts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyingLegSecurityAltID[] = {  {&_swigt__p_FIX__NoUnderlyingLegSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyingSecurityAltID[] = {  {&_swigt__p_FIX__NoUnderlyingSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyingStips[] = {  {&_swigt__p_FIX__NoUnderlyingStips, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUnderlyings[] = {  {&_swigt__p_FIX__NoUnderlyings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUndlyInstrumentParties[] = {  {&_swigt__p_FIX__NoUndlyInstrumentParties, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NoUndlyInstrumentPartySubIDs[] = {  {&_swigt__p_FIX__NoUndlyInstrumentPartySubIDs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NotAffOrigClOrdID[] = {  {&_swigt__p_FIX__NotAffOrigClOrdID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NotAffectedOrderID[] = {  {&_swigt__p_FIX__NotAffectedOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NotifyBrokerOfCredit[] = {  {&_swigt__p_FIX__NotifyBrokerOfCredit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NotionalPercentageOutstanding[] = {  {&_swigt__p_FIX__NotionalPercentageOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NullApplication[] = {  {&_swigt__p_FIX__NullApplication, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NullLog[] = {  {&_swigt__p_FIX__NullLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NumBidders[] = {  {&_swigt__p_FIX__NumBidders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NumDaysInterest[] = {  {&_swigt__p_FIX__NumDaysInterest, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NumTickets[] = {  {&_swigt__p_FIX__NumTickets, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__NumberOfOrders[] = {  {&_swigt__p_FIX__NumberOfOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OddLot[] = {  {&_swigt__p_FIX__OddLot, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferForwardPoints[] = {  {&_swigt__p_FIX__OfferForwardPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferForwardPoints2[] = {  {&_swigt__p_FIX__OfferForwardPoints2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferPx[] = {  {&_swigt__p_FIX__OfferPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferSize[] = {  {&_swigt__p_FIX__OfferSize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferSpotRate[] = {  {&_swigt__p_FIX__OfferSpotRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferSwapPoints[] = {  {&_swigt__p_FIX__OfferSwapPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OfferYield[] = {  {&_swigt__p_FIX__OfferYield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OnBehalfOfCompID[] = {  {&_swigt__p_FIX__OnBehalfOfCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OnBehalfOfLocationID[] = {  {&_swigt__p_FIX__OnBehalfOfLocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OnBehalfOfSendingTime[] = {  {&_swigt__p_FIX__OnBehalfOfSendingTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OnBehalfOfSubID[] = {  {&_swigt__p_FIX__OnBehalfOfSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OpenClose[] = {  {&_swigt__p_FIX__OpenClose, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OpenCloseSettlFlag[] = {  {&_swigt__p_FIX__OpenCloseSettlFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OpenCloseSettleFlag[] = {  {&_swigt__p_FIX__OpenCloseSettleFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OpenInterest[] = {  {&_swigt__p_FIX__OpenInterest, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OptAttribute[] = {  {&_swigt__p_FIX__OptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OptPayAmount[] = {  {&_swigt__p_FIX__OptPayAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OptPayoutAmount[] = {  {&_swigt__p_FIX__OptPayoutAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OptPayoutType[] = {  {&_swigt__p_FIX__OptPayoutType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrdRejReason[] = {  {&_swigt__p_FIX__OrdRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrdStatus[] = {  {&_swigt__p_FIX__OrdStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrdStatusReqID[] = {  {&_swigt__p_FIX__OrdStatusReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrdType[] = {  {&_swigt__p_FIX__OrdType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderAvgPx[] = {  {&_swigt__p_FIX__OrderAvgPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderBookingQty[] = {  {&_swigt__p_FIX__OrderBookingQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderCapacity[] = {  {&_swigt__p_FIX__OrderCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderCapacityQty[] = {  {&_swigt__p_FIX__OrderCapacityQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderCategory[] = {  {&_swigt__p_FIX__OrderCategory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderDelay[] = {  {&_swigt__p_FIX__OrderDelay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderDelayUnit[] = {  {&_swigt__p_FIX__OrderDelayUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderHandlingInstSource[] = {  {&_swigt__p_FIX__OrderHandlingInstSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderID[] = {  {&_swigt__p_FIX__OrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderInputDevice[] = {  {&_swigt__p_FIX__OrderInputDevice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderPercent[] = {  {&_swigt__p_FIX__OrderPercent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderQty[] = {  {&_swigt__p_FIX__OrderQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderQty2[] = {  {&_swigt__p_FIX__OrderQty2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrderRestrictions[] = {  {&_swigt__p_FIX__OrderRestrictions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigClOrdID[] = {  {&_swigt__p_FIX__OrigClOrdID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigCrossID[] = {  {&_swigt__p_FIX__OrigCrossID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigCustOrderCapacity[] = {  {&_swigt__p_FIX__OrigCustOrderCapacity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigOrdModTime[] = {  {&_swigt__p_FIX__OrigOrdModTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigPosReqRefID[] = {  {&_swigt__p_FIX__OrigPosReqRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigSecondaryTradeID[] = {  {&_swigt__p_FIX__OrigSecondaryTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigSendingTime[] = {  {&_swigt__p_FIX__OrigSendingTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigTime[] = {  {&_swigt__p_FIX__OrigTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigTradeDate[] = {  {&_swigt__p_FIX__OrigTradeDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigTradeHandlingInstr[] = {  {&_swigt__p_FIX__OrigTradeHandlingInstr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OrigTradeID[] = {  {&_swigt__p_FIX__OrigTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OriginalNotionalPercentageOutstanding[] = {  {&_swigt__p_FIX__OriginalNotionalPercentageOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OutMainCntryUIndex[] = {  {&_swigt__p_FIX__OutMainCntryUIndex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OutsideIndexPct[] = {  {&_swigt__p_FIX__OutsideIndexPct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OwnerType[] = {  {&_swigt__p_FIX__OwnerType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__OwnershipType[] = {  {&_swigt__p_FIX__OwnershipType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PERCENTAGE[] = {  {&_swigt__p_FIX__PERCENTAGE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PRICE[] = {  {&_swigt__p_FIX__PRICE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PRICEOFFSET[] = {  {&_swigt__p_FIX__PRICEOFFSET, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ParentMktSegmID[] = {  {&_swigt__p_FIX__ParentMktSegmID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ParticipationRate[] = {  {&_swigt__p_FIX__ParticipationRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyID[] = {  {&_swigt__p_FIX__PartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyIDSource[] = {  {&_swigt__p_FIX__PartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartyRole[] = {  {&_swigt__p_FIX__PartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartySubID[] = {  {&_swigt__p_FIX__PartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PartySubIDType[] = {  {&_swigt__p_FIX__PartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Password[] = {  {&_swigt__p_FIX__Password, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PaymentDate[] = {  {&_swigt__p_FIX__PaymentDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PaymentMethod[] = {  {&_swigt__p_FIX__PaymentMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PaymentRef[] = {  {&_swigt__p_FIX__PaymentRef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PaymentRemitterID[] = {  {&_swigt__p_FIX__PaymentRemitterID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PctAtRisk[] = {  {&_swigt__p_FIX__PctAtRisk, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegDifference[] = {  {&_swigt__p_FIX__PegDifference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegLimitType[] = {  {&_swigt__p_FIX__PegLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegMoveType[] = {  {&_swigt__p_FIX__PegMoveType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegOffsetType[] = {  {&_swigt__p_FIX__PegOffsetType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegOffsetValue[] = {  {&_swigt__p_FIX__PegOffsetValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegPriceType[] = {  {&_swigt__p_FIX__PegPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegRoundDirection[] = {  {&_swigt__p_FIX__PegRoundDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegScope[] = {  {&_swigt__p_FIX__PegScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegSecurityDesc[] = {  {&_swigt__p_FIX__PegSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegSecurityID[] = {  {&_swigt__p_FIX__PegSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegSecurityIDSource[] = {  {&_swigt__p_FIX__PegSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PegSymbol[] = {  {&_swigt__p_FIX__PegSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PeggedPrice[] = {  {&_swigt__p_FIX__PeggedPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PeggedRefPrice[] = {  {&_swigt__p_FIX__PeggedRefPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Pool[] = {  {&_swigt__p_FIX__Pool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosAmt[] = {  {&_swigt__p_FIX__PosAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosAmtType[] = {  {&_swigt__p_FIX__PosAmtType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintAction[] = {  {&_swigt__p_FIX__PosMaintAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintResult[] = {  {&_swigt__p_FIX__PosMaintResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintRptID[] = {  {&_swigt__p_FIX__PosMaintRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintRptRefID[] = {  {&_swigt__p_FIX__PosMaintRptRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosMaintStatus[] = {  {&_swigt__p_FIX__PosMaintStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosQtyStatus[] = {  {&_swigt__p_FIX__PosQtyStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosReqID[] = {  {&_swigt__p_FIX__PosReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosReqResult[] = {  {&_swigt__p_FIX__PosReqResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosReqStatus[] = {  {&_swigt__p_FIX__PosReqStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosReqType[] = {  {&_swigt__p_FIX__PosReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosTransType[] = {  {&_swigt__p_FIX__PosTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PosType[] = {  {&_swigt__p_FIX__PosType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PositionCurrency[] = {  {&_swigt__p_FIX__PositionCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PositionEffect[] = {  {&_swigt__p_FIX__PositionEffect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PositionLimit[] = {  {&_swigt__p_FIX__PositionLimit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PossDupFlag[] = {  {&_swigt__p_FIX__PossDupFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PossResend[] = {  {&_swigt__p_FIX__PossResend, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PreTradeAnonymity[] = {  {&_swigt__p_FIX__PreTradeAnonymity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PreallocMethod[] = {  {&_swigt__p_FIX__PreallocMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PrevClosePx[] = {  {&_swigt__p_FIX__PrevClosePx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PreviouslyReported[] = {  {&_swigt__p_FIX__PreviouslyReported, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Price[] = {  {&_swigt__p_FIX__Price, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Price2[] = {  {&_swigt__p_FIX__Price2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceDelta[] = {  {&_swigt__p_FIX__PriceDelta, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceImprovement[] = {  {&_swigt__p_FIX__PriceImprovement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceLimitType[] = {  {&_swigt__p_FIX__PriceLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceProtectionScope[] = {  {&_swigt__p_FIX__PriceProtectionScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceQuoteMethod[] = {  {&_swigt__p_FIX__PriceQuoteMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceType[] = {  {&_swigt__p_FIX__PriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceUnitOfMeasure[] = {  {&_swigt__p_FIX__PriceUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriceUnitOfMeasureQty[] = {  {&_swigt__p_FIX__PriceUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriorSettlPrice[] = {  {&_swigt__p_FIX__PriorSettlPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriorSpreadIndicator[] = {  {&_swigt__p_FIX__PriorSpreadIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PriorityIndicator[] = {  {&_swigt__p_FIX__PriorityIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PrivateQuote[] = {  {&_swigt__p_FIX__PrivateQuote, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ProcessCode[] = {  {&_swigt__p_FIX__ProcessCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Product[] = {  {&_swigt__p_FIX__Product, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ProductComplex[] = {  {&_swigt__p_FIX__ProductComplex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ProgPeriodInterval[] = {  {&_swigt__p_FIX__ProgPeriodInterval, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ProgRptReqs[] = {  {&_swigt__p_FIX__ProgRptReqs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PublishTrdIndicator[] = {  {&_swigt__p_FIX__PublishTrdIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__PutOrCall[] = {  {&_swigt__p_FIX__PutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QTY[] = {  {&_swigt__p_FIX__QTY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QtyType[] = {  {&_swigt__p_FIX__QtyType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Quantity[] = {  {&_swigt__p_FIX__Quantity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuantityDate[] = {  {&_swigt__p_FIX__QuantityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuantityType[] = {  {&_swigt__p_FIX__QuantityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteAckStatus[] = {  {&_swigt__p_FIX__QuoteAckStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteCancelType[] = {  {&_swigt__p_FIX__QuoteCancelType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteCondition[] = {  {&_swigt__p_FIX__QuoteCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteEntryID[] = {  {&_swigt__p_FIX__QuoteEntryID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteEntryRejectReason[] = {  {&_swigt__p_FIX__QuoteEntryRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteEntryStatus[] = {  {&_swigt__p_FIX__QuoteEntryStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteID[] = {  {&_swigt__p_FIX__QuoteID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteMsgID[] = {  {&_swigt__p_FIX__QuoteMsgID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuotePriceType[] = {  {&_swigt__p_FIX__QuotePriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteQualifier[] = {  {&_swigt__p_FIX__QuoteQualifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRejectReason[] = {  {&_swigt__p_FIX__QuoteRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteReqID[] = {  {&_swigt__p_FIX__QuoteReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRequestRejectReason[] = {  {&_swigt__p_FIX__QuoteRequestRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRequestType[] = {  {&_swigt__p_FIX__QuoteRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRespID[] = {  {&_swigt__p_FIX__QuoteRespID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteRespType[] = {  {&_swigt__p_FIX__QuoteRespType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteResponseLevel[] = {  {&_swigt__p_FIX__QuoteResponseLevel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteSetID[] = {  {&_swigt__p_FIX__QuoteSetID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteSetValidUntilTime[] = {  {&_swigt__p_FIX__QuoteSetValidUntilTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteStatus[] = {  {&_swigt__p_FIX__QuoteStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteStatusReqID[] = {  {&_swigt__p_FIX__QuoteStatusReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__QuoteType[] = {  {&_swigt__p_FIX__QuoteType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RFQReqID[] = {  {&_swigt__p_FIX__RFQReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RateSource[] = {  {&_swigt__p_FIX__RateSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RateSourceType[] = {  {&_swigt__p_FIX__RateSourceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RatioQty[] = {  {&_swigt__p_FIX__RatioQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RawData[] = {  {&_swigt__p_FIX__RawData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RawDataLength[] = {  {&_swigt__p_FIX__RawDataLength, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReceivedDeptID[] = {  {&_swigt__p_FIX__ReceivedDeptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RedemptionDate[] = {  {&_swigt__p_FIX__RedemptionDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefAllocID[] = {  {&_swigt__p_FIX__RefAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplExtID[] = {  {&_swigt__p_FIX__RefApplExtID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplID[] = {  {&_swigt__p_FIX__RefApplID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplLastSeqNum[] = {  {&_swigt__p_FIX__RefApplLastSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplReqID[] = {  {&_swigt__p_FIX__RefApplReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefApplVerID[] = {  {&_swigt__p_FIX__RefApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefCompID[] = {  {&_swigt__p_FIX__RefCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefCstmApplVerID[] = {  {&_swigt__p_FIX__RefCstmApplVerID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefMsgType[] = {  {&_swigt__p_FIX__RefMsgType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefOrdIDReason[] = {  {&_swigt__p_FIX__RefOrdIDReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefOrderID[] = {  {&_swigt__p_FIX__RefOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefOrderIDSource[] = {  {&_swigt__p_FIX__RefOrderIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefSeqNum[] = {  {&_swigt__p_FIX__RefSeqNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefSubID[] = {  {&_swigt__p_FIX__RefSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefTagID[] = {  {&_swigt__p_FIX__RefTagID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReferencePage[] = {  {&_swigt__p_FIX__ReferencePage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefreshIndicator[] = {  {&_swigt__p_FIX__RefreshIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RefreshQty[] = {  {&_swigt__p_FIX__RefreshQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistAcctType[] = {  {&_swigt__p_FIX__RegistAcctType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistDetls[] = {  {&_swigt__p_FIX__RegistDetls, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistDtls[] = {  {&_swigt__p_FIX__RegistDtls, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistEmail[] = {  {&_swigt__p_FIX__RegistEmail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistID[] = {  {&_swigt__p_FIX__RegistID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistRefID[] = {  {&_swigt__p_FIX__RegistRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistRejReasonCode[] = {  {&_swigt__p_FIX__RegistRejReasonCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistRejReasonText[] = {  {&_swigt__p_FIX__RegistRejReasonText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistStatus[] = {  {&_swigt__p_FIX__RegistStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RegistTransType[] = {  {&_swigt__p_FIX__RegistTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RejectLogon[] = {  {&_swigt__p_FIX__RejectLogon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RejectText[] = {  {&_swigt__p_FIX__RejectText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelSymTransactTime[] = {  {&_swigt__p_FIX__RelSymTransactTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RelatdSym[] = {  {&_swigt__p_FIX__RelatdSym, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepeatedTag[] = {  {&_swigt__p_FIX__RepeatedTag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepeatingGroupCountMismatch[] = {  {&_swigt__p_FIX__RepeatingGroupCountMismatch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepoCollateralSecurityType[] = {  {&_swigt__p_FIX__RepoCollateralSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReportToExch[] = {  {&_swigt__p_FIX__ReportToExch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReportedPx[] = {  {&_swigt__p_FIX__ReportedPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReportedPxDiff[] = {  {&_swigt__p_FIX__ReportedPxDiff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepurchaseRate[] = {  {&_swigt__p_FIX__RepurchaseRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RepurchaseTerm[] = {  {&_swigt__p_FIX__RepurchaseTerm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RequiredTagMissing[] = {  {&_swigt__p_FIX__RequiredTagMissing, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ResetSeqNumFlag[] = {  {&_swigt__p_FIX__ResetSeqNumFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RespondentType[] = {  {&_swigt__p_FIX__RespondentType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ResponseDestination[] = {  {&_swigt__p_FIX__ResponseDestination, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ResponseTransportType[] = {  {&_swigt__p_FIX__ResponseTransportType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RestructuringType[] = {  {&_swigt__p_FIX__RestructuringType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ReversalIndicator[] = {  {&_swigt__p_FIX__ReversalIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RiskFreeRate[] = {  {&_swigt__p_FIX__RiskFreeRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RndPx[] = {  {&_swigt__p_FIX__RndPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartyID[] = {  {&_swigt__p_FIX__RootPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartyIDSource[] = {  {&_swigt__p_FIX__RootPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartyRole[] = {  {&_swigt__p_FIX__RootPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartySubID[] = {  {&_swigt__p_FIX__RootPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RootPartySubIDType[] = {  {&_swigt__p_FIX__RootPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoundLot[] = {  {&_swigt__p_FIX__RoundLot, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoundingDirection[] = {  {&_swigt__p_FIX__RoundingDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoundingModulus[] = {  {&_swigt__p_FIX__RoundingModulus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoutingID[] = {  {&_swigt__p_FIX__RoutingID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RoutingType[] = {  {&_swigt__p_FIX__RoutingType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RptSeq[] = {  {&_swigt__p_FIX__RptSeq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RptSys[] = {  {&_swigt__p_FIX__RptSys, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Rule80A[] = {  {&_swigt__p_FIX__Rule80A, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__RuntimeError[] = {  {&_swigt__p_FIX__RuntimeError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SEQNUM[] = {  {&_swigt__p_FIX__SEQNUM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__STRING[] = {  {&_swigt__p_FIX__STRING, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Scope[] = {  {&_swigt__p_FIX__Scope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ScreenLog[] = {  {&_swigt__p_FIX__ScreenLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ScreenLogFactory[] = {  {&_swigt__p_FIX__ScreenLogFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryAllocID[] = {  {&_swigt__p_FIX__SecondaryAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryClOrdID[] = {  {&_swigt__p_FIX__SecondaryClOrdID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryDisplayQty[] = {  {&_swigt__p_FIX__SecondaryDisplayQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryExecID[] = {  {&_swigt__p_FIX__SecondaryExecID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryFirmTradeID[] = {  {&_swigt__p_FIX__SecondaryFirmTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryHighLimitPrice[] = {  {&_swigt__p_FIX__SecondaryHighLimitPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryIndividualAllocID[] = {  {&_swigt__p_FIX__SecondaryIndividualAllocID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryLowLimitPrice[] = {  {&_swigt__p_FIX__SecondaryLowLimitPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryOrderID[] = {  {&_swigt__p_FIX__SecondaryOrderID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryPriceLimitType[] = {  {&_swigt__p_FIX__SecondaryPriceLimitType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTradeID[] = {  {&_swigt__p_FIX__SecondaryTradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTradeReportID[] = {  {&_swigt__p_FIX__SecondaryTradeReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTradeReportRefID[] = {  {&_swigt__p_FIX__SecondaryTradeReportRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTradingReferencePrice[] = {  {&_swigt__p_FIX__SecondaryTradingReferencePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecondaryTrdType[] = {  {&_swigt__p_FIX__SecondaryTrdType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecureData[] = {  {&_swigt__p_FIX__SecureData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecureDataLen[] = {  {&_swigt__p_FIX__SecureDataLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityAltID[] = {  {&_swigt__p_FIX__SecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityAltIDSource[] = {  {&_swigt__p_FIX__SecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityDesc[] = {  {&_swigt__p_FIX__SecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityExchange[] = {  {&_swigt__p_FIX__SecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityGroup[] = {  {&_swigt__p_FIX__SecurityGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityID[] = {  {&_swigt__p_FIX__SecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityIDSource[] = {  {&_swigt__p_FIX__SecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListDesc[] = {  {&_swigt__p_FIX__SecurityListDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListID[] = {  {&_swigt__p_FIX__SecurityListID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListRefID[] = {  {&_swigt__p_FIX__SecurityListRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListRequestType[] = {  {&_swigt__p_FIX__SecurityListRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListType[] = {  {&_swigt__p_FIX__SecurityListType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityListTypeSource[] = {  {&_swigt__p_FIX__SecurityListTypeSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityReportID[] = {  {&_swigt__p_FIX__SecurityReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityReqID[] = {  {&_swigt__p_FIX__SecurityReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityRequestResult[] = {  {&_swigt__p_FIX__SecurityRequestResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityRequestType[] = {  {&_swigt__p_FIX__SecurityRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityResponseID[] = {  {&_swigt__p_FIX__SecurityResponseID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityResponseType[] = {  {&_swigt__p_FIX__SecurityResponseType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentAcctName[] = {  {&_swigt__p_FIX__SecuritySettlAgentAcctName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentAcctNum[] = {  {&_swigt__p_FIX__SecuritySettlAgentAcctNum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentCode[] = {  {&_swigt__p_FIX__SecuritySettlAgentCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentContactName[] = {  {&_swigt__p_FIX__SecuritySettlAgentContactName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentContactPhone[] = {  {&_swigt__p_FIX__SecuritySettlAgentContactPhone, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySettlAgentName[] = {  {&_swigt__p_FIX__SecuritySettlAgentName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityStatus[] = {  {&_swigt__p_FIX__SecurityStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityStatusReqID[] = {  {&_swigt__p_FIX__SecurityStatusReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecuritySubType[] = {  {&_swigt__p_FIX__SecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityTradingEvent[] = {  {&_swigt__p_FIX__SecurityTradingEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityTradingStatus[] = {  {&_swigt__p_FIX__SecurityTradingStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityType[] = {  {&_swigt__p_FIX__SecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityUpdateAction[] = {  {&_swigt__p_FIX__SecurityUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityXML[] = {  {&_swigt__p_FIX__SecurityXML, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityXMLLen[] = {  {&_swigt__p_FIX__SecurityXMLLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SecurityXMLSchema[] = {  {&_swigt__p_FIX__SecurityXMLSchema, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SellVolume[] = {  {&_swigt__p_FIX__SellVolume, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SellerDays[] = {  {&_swigt__p_FIX__SellerDays, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SenderCompID[] = {  {&_swigt__p_FIX__SenderCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SenderLocationID[] = {  {&_swigt__p_FIX__SenderLocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SenderSubID[] = {  {&_swigt__p_FIX__SenderSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SendingDate[] = {  {&_swigt__p_FIX__SendingDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SendingTime[] = {  {&_swigt__p_FIX__SendingTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Seniority[] = {  {&_swigt__p_FIX__Seniority, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Session[] = {  {&_swigt__p_FIX__Session, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionID[] = {  {&_swigt__p_FIX__SessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionNotFound[] = {  {&_swigt__p_FIX__SessionNotFound, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionRejectReason[] = {  {&_swigt__p_FIX__SessionRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionSettings[] = {  {&_swigt__p_FIX__SessionSettings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SessionStatus[] = {  {&_swigt__p_FIX__SessionStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlBrkrCode[] = {  {&_swigt__p_FIX__SettlBrkrCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrAmt[] = {  {&_swigt__p_FIX__SettlCurrAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrBidFxRate[] = {  {&_swigt__p_FIX__SettlCurrBidFxRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrFxRate[] = {  {&_swigt__p_FIX__SettlCurrFxRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrFxRateCalc[] = {  {&_swigt__p_FIX__SettlCurrFxRateCalc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrOfferFxRate[] = {  {&_swigt__p_FIX__SettlCurrOfferFxRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlCurrency[] = {  {&_swigt__p_FIX__SettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlDate[] = {  {&_swigt__p_FIX__SettlDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlDate2[] = {  {&_swigt__p_FIX__SettlDate2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlDeliveryType[] = {  {&_swigt__p_FIX__SettlDeliveryType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlDepositoryCode[] = {  {&_swigt__p_FIX__SettlDepositoryCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstCode[] = {  {&_swigt__p_FIX__SettlInstCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstID[] = {  {&_swigt__p_FIX__SettlInstID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstMode[] = {  {&_swigt__p_FIX__SettlInstMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstMsgID[] = {  {&_swigt__p_FIX__SettlInstMsgID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstRefID[] = {  {&_swigt__p_FIX__SettlInstRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstReqID[] = {  {&_swigt__p_FIX__SettlInstReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstReqRejCode[] = {  {&_swigt__p_FIX__SettlInstReqRejCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstSource[] = {  {&_swigt__p_FIX__SettlInstSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlInstTransType[] = {  {&_swigt__p_FIX__SettlInstTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlLocation[] = {  {&_swigt__p_FIX__SettlLocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlMethod[] = {  {&_swigt__p_FIX__SettlMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligID[] = {  {&_swigt__p_FIX__SettlObligID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligMode[] = {  {&_swigt__p_FIX__SettlObligMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligMsgID[] = {  {&_swigt__p_FIX__SettlObligMsgID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligRefID[] = {  {&_swigt__p_FIX__SettlObligRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligSource[] = {  {&_swigt__p_FIX__SettlObligSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlObligTransType[] = {  {&_swigt__p_FIX__SettlObligTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartyID[] = {  {&_swigt__p_FIX__SettlPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartyIDSource[] = {  {&_swigt__p_FIX__SettlPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartyRole[] = {  {&_swigt__p_FIX__SettlPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartySubID[] = {  {&_swigt__p_FIX__SettlPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPartySubIDType[] = {  {&_swigt__p_FIX__SettlPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPrice[] = {  {&_swigt__p_FIX__SettlPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlPriceType[] = {  {&_swigt__p_FIX__SettlPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlSessID[] = {  {&_swigt__p_FIX__SettlSessID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlSessSubID[] = {  {&_swigt__p_FIX__SettlSessSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlType[] = {  {&_swigt__p_FIX__SettlType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettleOnOpenFlag[] = {  {&_swigt__p_FIX__SettleOnOpenFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlementCycleNo[] = {  {&_swigt__p_FIX__SettlementCycleNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SettlmntTyp[] = {  {&_swigt__p_FIX__SettlmntTyp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SharedCommission[] = {  {&_swigt__p_FIX__SharedCommission, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Shares[] = {  {&_swigt__p_FIX__Shares, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ShortQty[] = {  {&_swigt__p_FIX__ShortQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ShortSaleReason[] = {  {&_swigt__p_FIX__ShortSaleReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Side[] = {  {&_swigt__p_FIX__Side, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideComplianceID[] = {  {&_swigt__p_FIX__SideComplianceID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideCurrency[] = {  {&_swigt__p_FIX__SideCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideExecID[] = {  {&_swigt__p_FIX__SideExecID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideFillStationCd[] = {  {&_swigt__p_FIX__SideFillStationCd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideGrossTradeAmt[] = {  {&_swigt__p_FIX__SideGrossTradeAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideLastQty[] = {  {&_swigt__p_FIX__SideLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideLiquidityInd[] = {  {&_swigt__p_FIX__SideLiquidityInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideMultiLegReportingType[] = {  {&_swigt__p_FIX__SideMultiLegReportingType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideQty[] = {  {&_swigt__p_FIX__SideQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideReasonCd[] = {  {&_swigt__p_FIX__SideReasonCd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideSettlCurrency[] = {  {&_swigt__p_FIX__SideSettlCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTimeInForce[] = {  {&_swigt__p_FIX__SideTimeInForce, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTradeReportID[] = {  {&_swigt__p_FIX__SideTradeReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTrdRegTimestamp[] = {  {&_swigt__p_FIX__SideTrdRegTimestamp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTrdRegTimestampSrc[] = {  {&_swigt__p_FIX__SideTrdRegTimestampSrc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTrdRegTimestampType[] = {  {&_swigt__p_FIX__SideTrdRegTimestampType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideTrdSubTyp[] = {  {&_swigt__p_FIX__SideTrdSubTyp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideValue1[] = {  {&_swigt__p_FIX__SideValue1, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideValue2[] = {  {&_swigt__p_FIX__SideValue2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SideValueInd[] = {  {&_swigt__p_FIX__SideValueInd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Signature[] = {  {&_swigt__p_FIX__Signature, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SignatureLength[] = {  {&_swigt__p_FIX__SignatureLength, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketAcceptor[] = {  {&_swigt__p_FIX__SocketAcceptor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketCloseFailed[] = {  {&_swigt__p_FIX__SocketCloseFailed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketException[] = {  {&_swigt__p_FIX__SocketSendFailed, _p_FIX__SocketSendFailedTo_p_FIX__SocketException, 0, 0},  {&_swigt__p_FIX__SocketRecvFailed, _p_FIX__SocketRecvFailedTo_p_FIX__SocketException, 0, 0},  {&_swigt__p_FIX__SocketException, 0, 0, 0},  {&_swigt__p_FIX__SocketCloseFailed, _p_FIX__SocketCloseFailedTo_p_FIX__SocketException, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketInitiator[] = {  {&_swigt__p_FIX__SocketInitiator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketRecvFailed[] = {  {&_swigt__p_FIX__SocketRecvFailed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SocketSendFailed[] = {  {&_swigt__p_FIX__SocketSendFailed, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SolicitedFlag[] = {  {&_swigt__p_FIX__SolicitedFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Spread[] = {  {&_swigt__p_FIX__Spread, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SpreadToBenchmark[] = {  {&_swigt__p_FIX__SpreadToBenchmark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StandInstDbID[] = {  {&_swigt__p_FIX__StandInstDbID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StandInstDbName[] = {  {&_swigt__p_FIX__StandInstDbName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StandInstDbType[] = {  {&_swigt__p_FIX__StandInstDbType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartCash[] = {  {&_swigt__p_FIX__StartCash, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartDate[] = {  {&_swigt__p_FIX__StartDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartMaturityMonthYear[] = {  {&_swigt__p_FIX__StartMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartStrikePxRange[] = {  {&_swigt__p_FIX__StartStrikePxRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StartTickPriceRange[] = {  {&_swigt__p_FIX__StartTickPriceRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StateOrProvinceOfIssue[] = {  {&_swigt__p_FIX__StateOrProvinceOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StatsType[] = {  {&_swigt__p_FIX__StatsType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StatusText[] = {  {&_swigt__p_FIX__StatusText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StatusValue[] = {  {&_swigt__p_FIX__StatusValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StipulationType[] = {  {&_swigt__p_FIX__StipulationType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StipulationValue[] = {  {&_swigt__p_FIX__StipulationValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StopPx[] = {  {&_swigt__p_FIX__StopPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrategyParameterName[] = {  {&_swigt__p_FIX__StrategyParameterName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrategyParameterType[] = {  {&_swigt__p_FIX__StrategyParameterType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrategyParameterValue[] = {  {&_swigt__p_FIX__StrategyParameterValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnAckType[] = {  {&_swigt__p_FIX__StreamAsgnAckType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnRejReason[] = {  {&_swigt__p_FIX__StreamAsgnRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnReqID[] = {  {&_swigt__p_FIX__StreamAsgnReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnReqType[] = {  {&_swigt__p_FIX__StreamAsgnReqType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnRptID[] = {  {&_swigt__p_FIX__StreamAsgnRptID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StreamAsgnType[] = {  {&_swigt__p_FIX__StreamAsgnType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeCurrency[] = {  {&_swigt__p_FIX__StrikeCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeExerciseStyle[] = {  {&_swigt__p_FIX__StrikeExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeIncrement[] = {  {&_swigt__p_FIX__StrikeIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeMultiplier[] = {  {&_swigt__p_FIX__StrikeMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikePrice[] = {  {&_swigt__p_FIX__StrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikePriceBoundaryMethod[] = {  {&_swigt__p_FIX__StrikePriceBoundaryMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikePriceBoundaryPrecision[] = {  {&_swigt__p_FIX__StrikePriceBoundaryPrecision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikePriceDeterminationMethod[] = {  {&_swigt__p_FIX__StrikePriceDeterminationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeRuleID[] = {  {&_swigt__p_FIX__StrikeRuleID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeTime[] = {  {&_swigt__p_FIX__StrikeTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StrikeValue[] = {  {&_swigt__p_FIX__StrikeValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__StringField[] = {  {&_swigt__p_FIX__DeliveryDate, _p_FIX__DeliveryDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RFQReqID, _p_FIX__RFQReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedText, _p_FIX__EncodedTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BidID, _p_FIX__BidIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeCondition, _p_FIX__TradeConditionTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteCondition, _p_FIX__QuoteConditionTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExchangeRule, _p_FIX__ExchangeRuleTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FutSettDate2, _p_FIX__FutSettDate2To_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollAsgnID, _p_FIX__CollAsgnIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeRequestID, _p_FIX__TradeRequestIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UserRequestID, _p_FIX__UserRequestIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NetworkRequestID, _p_FIX__NetworkRequestIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClientBidID, _p_FIX__ClientBidIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ReferencePage, _p_FIX__ReferencePageTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Text, _p_FIX__TextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDFeedType, _p_FIX__MDFeedTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UserStatusText, _p_FIX__UserStatusTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StatusText, _p_FIX__StatusTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ListStatusText, _p_FIX__ListStatusTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedListStatusText, _p_FIX__EncodedListStatusTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIid, _p_FIX__IOIidTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlDate, _p_FIX__SettlDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSettlDate, _p_FIX__LegSettlDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeskType, _p_FIX__DeskTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PriceUnitOfMeasure, _p_FIX__PriceUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnitOfMeasure, _p_FIX__UnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativePriceUnitOfMeasure, _p_FIX__DerivativePriceUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeUnitOfMeasure, _p_FIX__DerivativeUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegPriceUnitOfMeasure, _p_FIX__LegPriceUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegUnitOfMeasure, _p_FIX__LegUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingUnitOfMeasure, _p_FIX__UnderlyingUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasure, _p_FIX__UnderlyingPriceUnitOfMeasureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TransferReason, _p_FIX__TransferReasonTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrRegistry, _p_FIX__DerivativeInstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegInstrRegistry, _p_FIX__LegInstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrRegistry, _p_FIX__InstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrRegistry, _p_FIX__UnderlyingInstrRegistryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedSecurityDesc, _p_FIX__DerivativeEncodedSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityDesc, _p_FIX__DerivativeSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerSecurityDesc, _p_FIX__TriggerSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PegSecurityDesc, _p_FIX__PegSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityDesc, _p_FIX__UnderlyingLegSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityDesc, _p_FIX__UnderlyingSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityDesc, _p_FIX__SecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingSecurityDesc, _p_FIX__EncodedUnderlyingSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedLegSecurityDesc, _p_FIX__EncodedLegSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedSecurityDesc, _p_FIX__EncodedSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityDesc, _p_FIX__LegSecurityDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Username, _p_FIX__UsernameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistRejReasonText, _p_FIX__RegistRejReasonTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlBrkrCode, _p_FIX__SettlBrkrCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefApplID, _p_FIX__RefApplIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplID, _p_FIX__ApplIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Pool, _p_FIX__PoolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestampSrc, _p_FIX__SideTrdRegTimestampSrcTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SendingDate, _p_FIX__SendingDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartyID, _p_FIX__UndlyInstrumentPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetPartyID, _p_FIX__TargetPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NestedPartyID, _p_FIX__NestedPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested3PartyID, _p_FIX__Nested3PartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartyID, _p_FIX__UnderlyingInstrumentPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlPartyID, _p_FIX__SettlPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested4PartyID, _p_FIX__Nested4PartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PartyID, _p_FIX__PartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RootPartyID, _p_FIX__RootPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyID, _p_FIX__DerivativeInstrumentPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrumentPartyID, _p_FIX__InstrumentPartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested2PartyID, _p_FIX__Nested2PartyIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollInquiryID, _p_FIX__CollInquiryIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlSessID, _p_FIX__SettlSessIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketSegmentDesc, _p_FIX__MarketSegmentDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AgreementDesc, _p_FIX__AgreementDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteReqID, _p_FIX__QuoteReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FillExecID, _p_FIX__FillExecIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryExecID, _p_FIX__SecondaryExecIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExecID, _p_FIX__ExecIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideExecID, _p_FIX__SideExecIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentName, _p_FIX__CashSettlAgentNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribAgentName, _p_FIX__CashDistribAgentNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentName, _p_FIX__SecuritySettlAgentNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntryOriginator, _p_FIX__MDEntryOriginatorTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegStipulationType, _p_FIX__LegStipulationTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StipulationType, _p_FIX__StipulationTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstCode, _p_FIX__SettlInstCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MailingDtls, _p_FIX__MailingDtlsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityAltID, _p_FIX__LegSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityAltID, _p_FIX__SecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityAltID, _p_FIX__UnderlyingLegSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityAltID, _p_FIX__DerivativeSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityAltID, _p_FIX__UnderlyingSecurityAltIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedAllocText, _p_FIX__EncodedAllocTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocText, _p_FIX__AllocTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClientID, _p_FIX__ClientIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetSubID, _p_FIX__TargetSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RelatdSym, _p_FIX__RelatdSymTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentContactName, _p_FIX__SecuritySettlAgentContactNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentAcctName, _p_FIX__SecuritySettlAgentAcctNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribAgentAcctName, _p_FIX__CashDistribAgentAcctNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentAcctName, _p_FIX__CashSettlAgentAcctNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentContactName, _p_FIX__CashSettlAgentContactNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplVerID, _p_FIX__ApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefCstmApplVerID, _p_FIX__RefCstmApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DefaultApplVerID, _p_FIX__DefaultApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CstmApplVerID, _p_FIX__CstmApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefApplVerID, _p_FIX__RefApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DefaultCstmApplVerID, _p_FIX__DefaultCstmApplVerIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Country, _p_FIX__CountryTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardHolderName, _p_FIX__CardHolderNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StrategyParameterName, _p_FIX__StrategyParameterNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SenderLocationID, _p_FIX__SenderLocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LocationID, _p_FIX__LocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetLocationID, _p_FIX__TargetLocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OnBehalfOfLocationID, _p_FIX__OnBehalfOfLocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeliverToLocationID, _p_FIX__DeliverToLocationIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeInputDevice, _p_FIX__TradeInputDeviceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrderInputDevice, _p_FIX__OrderInputDeviceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllowableOneSidednessCurr, _p_FIX__AllowableOneSidednessCurrTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegAllocSettlCurrency, _p_FIX__LegAllocSettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PositionCurrency, _p_FIX__PositionCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCurrency, _p_FIX__UnderlyingCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CommCurrency, _p_FIX__CommCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingStrikeCurrency, _p_FIX__UnderlyingStrikeCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeStrikeCurrency, _p_FIX__DerivativeStrikeCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AgreementCurrency, _p_FIX__AgreementCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradingCurrency, _p_FIX__TradingCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Currency, _p_FIX__CurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StrikeCurrency, _p_FIX__StrikeCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlCurrency, _p_FIX__SettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSettlCurrency, _p_FIX__LegSettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCurrency, _p_FIX__LegCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideCurrency, _p_FIX__SideCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocSettlCurrency, _p_FIX__AllocSettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkCurveCurrency, _p_FIX__BenchmarkCurveCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurveCurrency, _p_FIX__LegBenchmarkCurveCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideSettlCurrency, _p_FIX__SideSettlCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegStrikeCurrency, _p_FIX__LegStrikeCurrencyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClearingFeeIndicator, _p_FIX__ClearingFeeIndicatorTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocClearingFeeIndicator, _p_FIX__AllocClearingFeeIndicatorTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementStatus, _p_FIX__UnderlyingSettlementStatusTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FinancialStatus, _p_FIX__FinancialStatusTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocCustomerCapacity, _p_FIX__AllocCustomerCapacityTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityStatus, _p_FIX__SecurityStatusTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityStatus, _p_FIX__DerivativeSecurityStatusTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDReqID, _p_FIX__MDReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntryRefID, _p_FIX__MDEntryRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Signature, _p_FIX__SignatureTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StandInstDbID, _p_FIX__StandInstDbIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstMsgID, _p_FIX__SettlInstMsgIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BrokerOfCredit, _p_FIX__BrokerOfCreditTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigTradeDate, _p_FIX__OrigTradeDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeDate, _p_FIX__TradeDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DatedDate, _p_FIX__DatedDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegDatedDate, _p_FIX__LegDatedDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CrossID, _p_FIX__CrossIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigCrossID, _p_FIX__OrigCrossIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__HostCrossID, _p_FIX__HostCrossIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollAsgnRefID, _p_FIX__CollAsgnRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityReqID, _p_FIX__SecurityReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OpenCloseSettlFlag, _p_FIX__OpenCloseSettlFlagTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AffectedSecondaryOrderID, _p_FIX__AffectedSecondaryOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefOrderID, _p_FIX__RefOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryOrderID, _p_FIX__SecondaryOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NotAffectedOrderID, _p_FIX__NotAffectedOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrderID, _p_FIX__OrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AffectedOrderID, _p_FIX__AffectedOrderIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MailingInst, _p_FIX__MailingInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CustOrderHandlingInst, _p_FIX__CustOrderHandlingInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeskOrderHandlingInst, _p_FIX__DeskOrderHandlingInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlSessSubID, _p_FIX__SettlSessSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurvePoint, _p_FIX__LegBenchmarkCurvePointTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkCurvePoint, _p_FIX__BenchmarkCurvePointTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContraTrader, _p_FIX__ContraTraderTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PaymentRef, _p_FIX__PaymentRefTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradingSessionID, _p_FIX__TradingSessionIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerTradingSessionID, _p_FIX__TriggerTradingSessionIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingTradingSessionID, _p_FIX__UnderlyingTradingSessionIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Scope, _p_FIX__ScopeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StreamAsgnReqID, _p_FIX__StreamAsgnReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstID, _p_FIX__SettlInstIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExecRefID, _p_FIX__ExecRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FutSettDate, _p_FIX__FutSettDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegFutSettDate, _p_FIX__LegFutSettDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardExpDate, _p_FIX__CardExpDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExDate, _p_FIX__ExDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteSetID, _p_FIX__QuoteSetIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribAgentAcctNumber, _p_FIX__CashDistribAgentAcctNumberTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardNumber, _p_FIX__CardNumberTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LastNetworkResponseID, _p_FIX__LastNetworkResponseIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityResponseID, _p_FIX__SecurityResponseIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NetworkResponseID, _p_FIX__NetworkResponseIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplResponseID, _p_FIX__ApplResponseIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LastMkt, _p_FIX__LastMktTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDMkt, _p_FIX__MDMktTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntrySeller, _p_FIX__MDEntrySellerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RedemptionDate, _p_FIX__RedemptionDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeOriginationDate, _p_FIX__TradeOriginationDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegRedemptionDate, _p_FIX__LegRedemptionDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingRedemptionDate, _p_FIX__UnderlyingRedemptionDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__YieldRedemptionDate, _p_FIX__YieldRedemptionDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryFirmTradeID, _p_FIX__SecondaryFirmTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeID, _p_FIX__TradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FirmTradeID, _p_FIX__FirmTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryTradeID, _p_FIX__SecondaryTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigTradeID, _p_FIX__OrigTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigSecondaryTradeID, _p_FIX__OrigSecondaryTradeIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InvestorCountryOfResidence, _p_FIX__InvestorCountryOfResidenceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CreditRating, _p_FIX__CreditRatingTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCreditRating, _p_FIX__LegCreditRatingTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCreditRating, _p_FIX__UnderlyingCreditRatingTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ConfirmRefID, _p_FIX__ConfirmRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntryBuyer, _p_FIX__MDEntryBuyerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SenderSubID, _p_FIX__SenderSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCashType, _p_FIX__UnderlyingCashTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TrdRegTimestampOrigin, _p_FIX__TrdRegTimestampOriginTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TrdMatchID, _p_FIX__TrdMatchIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ConfirmReqID, _p_FIX__ConfirmReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityRuleID, _p_FIX__MaturityRuleIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StrikeRuleID, _p_FIX__StrikeRuleIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerSecurityID, _p_FIX__TriggerSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityID, _p_FIX__LegSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityID, _p_FIX__SecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityID, _p_FIX__DerivativeSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkSecurityID, _p_FIX__BenchmarkSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PegSecurityID, _p_FIX__PegSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityID, _p_FIX__UnderlyingSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityID, _p_FIX__UnderlyingLegSecurityIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefCompID, _p_FIX__RefCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SenderCompID, _p_FIX__SenderCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetCompID, _p_FIX__TargetCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__HopCompID, _p_FIX__HopCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OnBehalfOfCompID, _p_FIX__OnBehalfOfCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentContactPhone, _p_FIX__CashSettlAgentContactPhoneTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentContactPhone, _p_FIX__SecuritySettlAgentContactPhoneTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeliverToCompID, _p_FIX__DeliverToCompIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ConfirmID, _p_FIX__ConfirmIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EndDate, _p_FIX__EndDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegStateOrProvinceOfIssue, _p_FIX__LegStateOrProvinceOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCountryOfIssue, _p_FIX__LegCountryOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingStateOrProvinceOfIssue, _p_FIX__UnderlyingStateOrProvinceOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeCountryOfIssue, _p_FIX__DerivativeCountryOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeStateOrProvinceOfIssue, _p_FIX__DerivativeStateOrProvinceOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCountryOfIssue, _p_FIX__UnderlyingCountryOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LocaleOfIssue, _p_FIX__LocaleOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegLocaleOfIssue, _p_FIX__LegLocaleOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StateOrProvinceOfIssue, _p_FIX__StateOrProvinceOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CountryOfIssue, _p_FIX__CountryOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeLocaleOfIssue, _p_FIX__DerivativeLocaleOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLocaleOfIssue, _p_FIX__UnderlyingLocaleOfIssueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__YieldType, _p_FIX__YieldTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerSymbol, _p_FIX__TriggerSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Symbol, _p_FIX__SymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSymbol, _p_FIX__UnderlyingLegSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PegSymbol, _p_FIX__PegSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSymbol, _p_FIX__UnderlyingSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSymbol, _p_FIX__LegSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSymbol, _p_FIX__DerivativeSymbolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AltMDSourceID, _p_FIX__AltMDSourceIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StrategyParameterValue, _p_FIX__StrategyParameterValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlMethod, _p_FIX__UnderlyingSettlMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeFuturesValuationMethod, _p_FIX__DerivativeFuturesValuationMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ValuationMethod, _p_FIX__ValuationMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__FuturesValuationMethod, _p_FIX__FuturesValuationMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeValuationMethod, _p_FIX__DerivativeValuationMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BeginString, _p_FIX__BeginStringTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativePriceQuoteMethod, _p_FIX__DerivativePriceQuoteMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PriceQuoteMethod, _p_FIX__PriceQuoteMethodTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__WaveNo, _p_FIX__WaveNoTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistDtls, _p_FIX__RegistDtlsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlObligMsgID, _p_FIX__SettlObligMsgIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Password, _p_FIX__PasswordTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NewPassword, _p_FIX__NewPasswordTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncryptedNewPassword, _p_FIX__EncryptedNewPasswordTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncryptedPassword, _p_FIX__EncryptedPasswordTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StringField, 0, 0, 0},  {&_swigt__p_FIX__MessageEncoding, _p_FIX__MessageEncodingTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIQty, _p_FIX__IOIQtyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegIOIQty, _p_FIX__LegIOIQtyTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefMsgType, _p_FIX__RefMsgTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MsgType, _p_FIX__MsgTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedMktSegmDesc, _p_FIX__EncodedMktSegmDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettleOnOpenFlag, _p_FIX__SettleOnOpenFlagTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSettleOnOpenFlag, _p_FIX__DerivativeSettleOnOpenFlagTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefApplReqID, _p_FIX__RefApplReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplReqID, _p_FIX__ApplReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollReqID, _p_FIX__CollReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXML, _p_FIX__DerivativeSecurityXMLTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityXML, _p_FIX__SecurityXMLTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TargetStrategyParameters, _p_FIX__TargetStrategyParametersTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityGroup, _p_FIX__DerivativeSecurityGroupTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityGroup, _p_FIX__SecurityGroupTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSeniority, _p_FIX__UnderlyingSeniorityTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Seniority, _p_FIX__SeniorityTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StartDate, _p_FIX__StartDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardStartDate, _p_FIX__CardStartDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefSubID, _p_FIX__RefSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OnBehalfOfSubID, _p_FIX__OnBehalfOfSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClearingBusinessDate, _p_FIX__ClearingBusinessDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MatchAlgorithm, _p_FIX__MatchAlgorithmTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ListID, _p_FIX__ListIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityListID, _p_FIX__SecurityListIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribPayRef, _p_FIX__CashDistribPayRefTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegExecInst, _p_FIX__LegExecInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedListExecInst, _p_FIX__EncodedListExecInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExecInst, _p_FIX__ExecInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ListExecInst, _p_FIX__ListExecInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryClOrdID, _p_FIX__SecondaryClOrdIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClOrdID, _p_FIX__ClOrdIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigClOrdID, _p_FIX__OrigClOrdIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NotAffOrigClOrdID, _p_FIX__NotAffOrigClOrdIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AdvRefID, _p_FIX__AdvRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__URLLink, _p_FIX__URLLinkTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideReasonCd, _p_FIX__SideReasonCdTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingStipType, _p_FIX__UnderlyingStipTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PaymentRemitterID, _p_FIX__PaymentRemitterIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeCFICode, _p_FIX__DerivativeCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCFICode, _p_FIX__LegCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCFICode, _p_FIX__UnderlyingCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CFICode, _p_FIX__CFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegCFICode, _p_FIX__UnderlyingLegCFICodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AsgnRptID, _p_FIX__AsgnRptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StreamAsgnRptID, _p_FIX__StreamAsgnRptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ApplReportID, _p_FIX__ApplReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideTradeReportID, _p_FIX__SideTradeReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocReportID, _p_FIX__AllocReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeReportID, _p_FIX__TradeReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegReportID, _p_FIX__LegReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryTradeReportID, _p_FIX__SecondaryTradeReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketReportID, _p_FIX__MarketReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MassActionReportID, _p_FIX__MassActionReportIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RoutingID, _p_FIX__RoutingIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExchangeSpecialInstructions, _p_FIX__ExchangeSpecialInstructionsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrderRestrictions, _p_FIX__OrderRestrictionsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TimeUnit, _p_FIX__TimeUnitTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegTimeUnit, _p_FIX__LegTimeUnitTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeTimeUnit, _p_FIX__DerivativeTimeUnitTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingTimeUnit, _p_FIX__UnderlyingTimeUnitTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExecBroker, _p_FIX__ExecBrokerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContraBroker, _p_FIX__ContraBrokerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NewsID, _p_FIX__NewsIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ParentMktSegmID, _p_FIX__ParentMktSegmIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Subject, _p_FIX__SubjectTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedSubject, _p_FIX__EncodedSubjectTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingStipValue, _p_FIX__UnderlyingStipValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityXMLSchema, _p_FIX__DerivativeSecurityXMLSchemaTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityXMLSchema, _p_FIX__SecurityXMLSchemaTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeEventText, _p_FIX__DerivativeEventTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EventText, _p_FIX__EventTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradingSessionDesc, _p_FIX__TradingSessionDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocID, _p_FIX__AllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegIndividualAllocID, _p_FIX__LegIndividualAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegAllocID, _p_FIX__LegAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryIndividualAllocID, _p_FIX__SecondaryIndividualAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RefAllocID, _p_FIX__RefAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IndividualAllocID, _p_FIX__IndividualAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryAllocID, _p_FIX__SecondaryAllocIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardIssNum, _p_FIX__CardIssNumTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RepoCollateralSecurityType, _p_FIX__RepoCollateralSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegRepoCollateralSecurityType, _p_FIX__LegRepoCollateralSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityType, _p_FIX__UnderlyingLegSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingRepoCollateralSecurityType, _p_FIX__UnderlyingRepoCollateralSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityType, _p_FIX__DerivativeSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityType, _p_FIX__LegSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribAgentCode, _p_FIX__CashDistribAgentCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityType, _p_FIX__SecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityType, _p_FIX__UnderlyingSecurityTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentCode, _p_FIX__SecuritySettlAgentCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentCode, _p_FIX__CashSettlAgentCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ReceivedDeptID, _p_FIX__ReceivedDeptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteMsgID, _p_FIX__QuoteMsgIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCPProgram, _p_FIX__UnderlyingCPProgramTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeliverToSubID, _p_FIX__DeliverToSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RejectText, _p_FIX__RejectTextTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIShares, _p_FIX__IOISharesTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingIssueDate, _p_FIX__UnderlyingIssueDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeIssueDate, _p_FIX__DerivativeIssueDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IssueDate, _p_FIX__IssueDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegIssueDate, _p_FIX__LegIssueDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteID, _p_FIX__QuoteIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityListDesc, _p_FIX__SecurityListDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClOrdLinkID, _p_FIX__ClOrdLinkIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedSecurityListDesc, _p_FIX__EncodedSecurityListDescTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TierCode, _p_FIX__TierCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeLinkID, _p_FIX__TradeLinkIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocLinkID, _p_FIX__AllocLinkIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedHeadline, _p_FIX__EncodedHeadlineTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Headline, _p_FIX__HeadlineTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistEmail, _p_FIX__RegistEmailTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityIDSource, _p_FIX__SecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartyIDSource, _p_FIX__DerivativeInstrumentPartyIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MessageEventSource, _p_FIX__MessageEventSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeInputSource, _p_FIX__TradeInputSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityIDSource, _p_FIX__LegSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityAltIDSource, _p_FIX__DerivativeSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityIDSource, _p_FIX__DerivativeSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkSecurityIDSource, _p_FIX__BenchmarkSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IDSource, _p_FIX__IDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContAmtCurr, _p_FIX__ContAmtCurrTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityAltIDSource, _p_FIX__UnderlyingLegSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityAltIDSource, _p_FIX__SecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingIDSource, _p_FIX__UnderlyingIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityAltIDSource, _p_FIX__LegSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerSecurityIDSource, _p_FIX__TriggerSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PegSecurityIDSource, _p_FIX__PegSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InputSource, _p_FIX__InputSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityIDSource, _p_FIX__UnderlyingSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegAllocAcctIDSource, _p_FIX__LegAllocAcctIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityAltIDSource, _p_FIX__UnderlyingSecurityAltIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityIDSource, _p_FIX__UnderlyingLegSecurityIDSourceTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityDay, _p_FIX__MaturityDayTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosType, _p_FIX__PosTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityDay, _p_FIX__UnderlyingMaturityDayTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ComplianceID, _p_FIX__ComplianceIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideComplianceID, _p_FIX__SideComplianceIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ListName, _p_FIX__ListNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClearingFirm, _p_FIX__ClearingFirmTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__YieldCalcDate, _p_FIX__YieldCalcDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OpenCloseSettleFlag, _p_FIX__OpenCloseSettleFlagTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityListRefID, _p_FIX__SecurityListRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstRefID, _p_FIX__SettlInstRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BusinessRejectRefID, _p_FIX__BusinessRejectRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistRefID, _p_FIX__RegistRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeReportRefID, _p_FIX__TradeReportRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocReportRefID, _p_FIX__AllocReportRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosMaintRptRefID, _p_FIX__PosMaintRptRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecondaryTradeReportRefID, _p_FIX__SecondaryTradeReportRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistAcctType, _p_FIX__RegistAcctTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SideFillStationCd, _p_FIX__SideFillStationCdTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested2PartySubID, _p_FIX__Nested2PartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NestedPartySubID, _p_FIX__NestedPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrumentPartySubID, _p_FIX__InstrumentPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteEntryID, _p_FIX__QuoteEntryIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RootPartySubID, _p_FIX__RootPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDEntryID, _p_FIX__MDEntryIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PartySubID, _p_FIX__PartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlPartySubID, _p_FIX__SettlPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingInstrumentPartySubID, _p_FIX__UnderlyingInstrumentPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested4PartySubID, _p_FIX__Nested4PartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Nested3PartySubID, _p_FIX__Nested3PartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrumentPartySubID, _p_FIX__DerivativeInstrumentPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UndlyInstrumentPartySubID, _p_FIX__UndlyInstrumentPartySubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__XmlData, _p_FIX__XmlDataTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MDStreamID, _p_FIX__MDStreamIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlInstReqID, _p_FIX__SettlInstReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketReqID, _p_FIX__MarketReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollRptID, _p_FIX__CollRptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TestReqID, _p_FIX__TestReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIRefID, _p_FIX__IOIRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySettlAgentAcctNum, _p_FIX__SecuritySettlAgentAcctNumTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashSettlAgentAcctNum, _p_FIX__CashSettlAgentAcctNumTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LanguageCode, _p_FIX__LanguageCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSymbolSfx, _p_FIX__UnderlyingLegSymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SymbolSfx, _p_FIX__SymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingTradingSessionSubID, _p_FIX__UnderlyingTradingSessionSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradingSessionSubID, _p_FIX__TradingSessionSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TriggerTradingSessionSubID, _p_FIX__TriggerTradingSessionSubIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSymbolSfx, _p_FIX__DerivativeSymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSymbolSfx, _p_FIX__UnderlyingSymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSymbolSfx, _p_FIX__LegSymbolSfxTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AllocAccount, _p_FIX__AllocAccountTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegAllocAccount, _p_FIX__LegAllocAccountTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ClearingAccount, _p_FIX__ClearingAccountTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Account, _p_FIX__AccountTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedIssuer, _p_FIX__EncodedIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeEncodedIssuer, _p_FIX__DerivativeEncodedIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Issuer, _p_FIX__IssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedLegIssuer, _p_FIX__EncodedLegIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingIssuer, _p_FIX__UnderlyingIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeIssuer, _p_FIX__DerivativeIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EncodedUnderlyingIssuer, _p_FIX__EncodedUnderlyingIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegIssuer, _p_FIX__LegIssuerTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BidDescriptor, _p_FIX__BidDescriptorTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecuritySubType, _p_FIX__UnderlyingLegSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecuritySubType, _p_FIX__DerivativeSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecuritySubType, _p_FIX__SecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecuritySubType, _p_FIX__LegSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecuritySubType, _p_FIX__UnderlyingSecuritySubTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TimeBracket, _p_FIX__TimeBracketTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosAmtType, _p_FIX__PosAmtTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AdvTransType, _p_FIX__AdvTransTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlDepositoryCode, _p_FIX__SettlDepositoryCodeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CPRegType, _p_FIX__CPRegTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegPool, _p_FIX__LegPoolTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCPRegType, _p_FIX__UnderlyingCPRegTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RawData, _p_FIX__RawDataTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketID, _p_FIX__MarketIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlDate2, _p_FIX__SettlDate2To_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DlvyInst, _p_FIX__DlvyInstTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DeskID, _p_FIX__DeskIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NewsRefID, _p_FIX__NewsRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CashDistribCurr, _p_FIX__CashDistribCurrTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MarketSegmentID, _p_FIX__MarketSegmentIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegStipulationValue, _p_FIX__LegStipulationValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AgreementID, _p_FIX__AgreementIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StipulationValue, _p_FIX__StipulationValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityDate, _p_FIX__DerivativeMaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityDate, _p_FIX__UnderlyingLegMaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuantityDate, _p_FIX__QuantityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityDate, _p_FIX__MaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegMaturityDate, _p_FIX__LegMaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityDate, _p_FIX__UnderlyingMaturityDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrdStatusReqID, _p_FIX__OrdStatusReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteStatusReqID, _p_FIX__QuoteStatusReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MassStatusReqID, _p_FIX__MassStatusReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradSesReqID, _p_FIX__TradSesReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosReqID, _p_FIX__PosReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityStatusReqID, _p_FIX__SecurityStatusReqIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StandInstDbName, _p_FIX__StandInstDbNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityTime, _p_FIX__DerivativeMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegMaturityTime, _p_FIX__LegMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityTime, _p_FIX__UnderlyingLegMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityTime, _p_FIX__UnderlyingMaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityTime, _p_FIX__MaturityTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__Designation, _p_FIX__DesignationTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExDestination, _p_FIX__ExDestinationTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ResponseDestination, _p_FIX__ResponseDestinationTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegInterestAccrualDate, _p_FIX__LegInterestAccrualDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InterestAccrualDate, _p_FIX__InterestAccrualDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CardIssNo, _p_FIX__CardIssNoTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegBenchmarkCurveName, _p_FIX__LegBenchmarkCurveNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BenchmarkCurveName, _p_FIX__BenchmarkCurveNameTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeEventDate, _p_FIX__DerivativeEventDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CouponPaymentDate, _p_FIX__CouponPaymentDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingCouponPaymentDate, _p_FIX__UnderlyingCouponPaymentDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PaymentDate, _p_FIX__PaymentDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSettlementDate, _p_FIX__UnderlyingSettlementDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EventDate, _p_FIX__EventDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AgreementDate, _p_FIX__AgreementDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegCouponPaymentDate, _p_FIX__LegCouponPaymentDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MatchType, _p_FIX__MatchTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CorporateAction, _p_FIX__CorporateActionTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EmailThreadID, _p_FIX__EmailThreadIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlLocation, _p_FIX__SettlLocationTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MiscFeeCurr, _p_FIX__MiscFeeCurrTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__IOIID, _p_FIX__IOIIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlType, _p_FIX__SettlTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistDetls, _p_FIX__RegistDetlsTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__AdvId, _p_FIX__AdvIdTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TZTransactTime, _p_FIX__TZTransactTimeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContraLegRefID, _p_FIX__ContraLegRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__TradeLegRefID, _p_FIX__TradeLegRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegRefID, _p_FIX__LegRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlObligRefID, _p_FIX__SettlObligRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContractSettlMonth, _p_FIX__ContractSettlMonthTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegContractSettlMonth, _p_FIX__LegContractSettlMonthTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BookingRefID, _p_FIX__BookingRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeContractSettlMonth, _p_FIX__DerivativeContractSettlMonthTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecureData, _p_FIX__SecureDataTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__InstrAttribValue, _p_FIX__InstrAttribValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__NestedInstrAttribValue, _p_FIX__NestedInstrAttribValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeInstrAttribValue, _p_FIX__DerivativeInstrAttribValueTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingSecurityExchange, _p_FIX__UnderlyingSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegSecurityExchange, _p_FIX__LegSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SecurityExchange, _p_FIX__SecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegSecurityExchange, _p_FIX__UnderlyingLegSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeSecurityExchange, _p_FIX__DerivativeSecurityExchangeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RestructuringType, _p_FIX__RestructuringTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingRestructuringType, _p_FIX__UnderlyingRestructuringTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DateOfBirth, _p_FIX__DateOfBirthTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ExpireDate, _p_FIX__ExpireDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__BasisFeatureDate, _p_FIX__BasisFeatureDateTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__CollRespID, _p_FIX__CollRespIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RptSys, _p_FIX__RptSysTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__QuoteRespID, _p_FIX__QuoteRespIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ProductComplex, _p_FIX__ProductComplexTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeProductComplex, _p_FIX__DerivativeProductComplexTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__SettlObligID, _p_FIX__SettlObligIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__RegistID, _p_FIX__RegistIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MiscFeeType, _p_FIX__MiscFeeTypeTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__LegMaturityMonthYear, _p_FIX__LegMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__StartMaturityMonthYear, _p_FIX__StartMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__MaturityMonthYear, _p_FIX__MaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__DerivativeMaturityMonthYear, _p_FIX__DerivativeMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingMaturityMonthYear, _p_FIX__UnderlyingMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__EndMaturityMonthYear, _p_FIX__EndMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__UnderlyingLegMaturityMonthYear, _p_FIX__UnderlyingLegMaturityMonthYearTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__OrigPosReqRefID, _p_FIX__OrigPosReqRefIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__PosMaintRptID, _p_FIX__PosMaintRptIDTo_p_FIX__StringField, 0, 0},  {&_swigt__p_FIX__ContIntRptID, _p_FIX__ContIntRptIDTo_p_FIX__StringField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Subject[] = {  {&_swigt__p_FIX__Subject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SubscriptionRequestType[] = {  {&_swigt__p_FIX__SubscriptionRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SwapPoints[] = {  {&_swigt__p_FIX__SwapPoints, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Symbol[] = {  {&_swigt__p_FIX__Symbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SymbolSfx[] = {  {&_swigt__p_FIX__SymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__SynchronizedApplication[] = {  {&_swigt__p_FIX__SynchronizedApplication, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TYPE__Type[] = {  {&_swigt__p_FIX__TYPE__Type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TZTIMEONLY[] = {  {&_swigt__p_FIX__TZTIMEONLY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TZTIMESTAMP[] = {  {&_swigt__p_FIX__TZTIMESTAMP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TZTransactTime[] = {  {&_swigt__p_FIX__TZTransactTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TagNotDefinedForMessage[] = {  {&_swigt__p_FIX__TagNotDefinedForMessage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TagOutOfOrder[] = {  {&_swigt__p_FIX__TagOutOfOrder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetCompID[] = {  {&_swigt__p_FIX__TargetCompID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetLocationID[] = {  {&_swigt__p_FIX__TargetLocationID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetPartyID[] = {  {&_swigt__p_FIX__TargetPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetPartyIDSource[] = {  {&_swigt__p_FIX__TargetPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetPartyRole[] = {  {&_swigt__p_FIX__TargetPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetStrategy[] = {  {&_swigt__p_FIX__TargetStrategy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetStrategyParameters[] = {  {&_swigt__p_FIX__TargetStrategyParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetStrategyPerformance[] = {  {&_swigt__p_FIX__TargetStrategyPerformance, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TargetSubID[] = {  {&_swigt__p_FIX__TargetSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TaxAdvantageType[] = {  {&_swigt__p_FIX__TaxAdvantageType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TerminationType[] = {  {&_swigt__p_FIX__TerminationType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TestMessageIndicator[] = {  {&_swigt__p_FIX__TestMessageIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TestReqID[] = {  {&_swigt__p_FIX__TestReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Text[] = {  {&_swigt__p_FIX__Text, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ThresholdAmount[] = {  {&_swigt__p_FIX__ThresholdAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TickDirection[] = {  {&_swigt__p_FIX__TickDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TickIncrement[] = {  {&_swigt__p_FIX__TickIncrement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TickRuleType[] = {  {&_swigt__p_FIX__TickRuleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TierCode[] = {  {&_swigt__p_FIX__TierCode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TimeBracket[] = {  {&_swigt__p_FIX__TimeBracket, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TimeInForce[] = {  {&_swigt__p_FIX__TimeInForce, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TimeToExpiration[] = {  {&_swigt__p_FIX__TimeToExpiration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TimeUnit[] = {  {&_swigt__p_FIX__TimeUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoAccQuotes[] = {  {&_swigt__p_FIX__TotNoAccQuotes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoAllocs[] = {  {&_swigt__p_FIX__TotNoAllocs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoCxldQuotes[] = {  {&_swigt__p_FIX__TotNoCxldQuotes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoFills[] = {  {&_swigt__p_FIX__TotNoFills, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoOrders[] = {  {&_swigt__p_FIX__TotNoOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoQuoteEntries[] = {  {&_swigt__p_FIX__TotNoQuoteEntries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoRejQuotes[] = {  {&_swigt__p_FIX__TotNoRejQuotes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoRelatedSym[] = {  {&_swigt__p_FIX__TotNoRelatedSym, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoSecurityTypes[] = {  {&_swigt__p_FIX__TotNoSecurityTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNoStrikes[] = {  {&_swigt__p_FIX__TotNoStrikes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNumAssignmentReports[] = {  {&_swigt__p_FIX__TotNumAssignmentReports, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNumReports[] = {  {&_swigt__p_FIX__TotNumReports, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotNumTradeReports[] = {  {&_swigt__p_FIX__TotNumTradeReports, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotQuoteEntries[] = {  {&_swigt__p_FIX__TotQuoteEntries, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalAccruedInterestAmt[] = {  {&_swigt__p_FIX__TotalAccruedInterestAmt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalAffectedOrders[] = {  {&_swigt__p_FIX__TotalAffectedOrders, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalNetValue[] = {  {&_swigt__p_FIX__TotalNetValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalNumPosReports[] = {  {&_swigt__p_FIX__TotalNumPosReports, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalNumSecurities[] = {  {&_swigt__p_FIX__TotalNumSecurities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalNumSecurityTypes[] = {  {&_swigt__p_FIX__TotalNumSecurityTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalTakedown[] = {  {&_swigt__p_FIX__TotalTakedown, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalVolumeTraded[] = {  {&_swigt__p_FIX__TotalVolumeTraded, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalVolumeTradedDate[] = {  {&_swigt__p_FIX__TotalVolumeTradedDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TotalVolumeTradedTime[] = {  {&_swigt__p_FIX__TotalVolumeTradedTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesCloseTime[] = {  {&_swigt__p_FIX__TradSesCloseTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesEndTime[] = {  {&_swigt__p_FIX__TradSesEndTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesEvent[] = {  {&_swigt__p_FIX__TradSesEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesMethod[] = {  {&_swigt__p_FIX__TradSesMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesMode[] = {  {&_swigt__p_FIX__TradSesMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesOpenTime[] = {  {&_swigt__p_FIX__TradSesOpenTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesPreCloseTime[] = {  {&_swigt__p_FIX__TradSesPreCloseTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesReqID[] = {  {&_swigt__p_FIX__TradSesReqID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesStartTime[] = {  {&_swigt__p_FIX__TradSesStartTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesStatus[] = {  {&_swigt__p_FIX__TradSesStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesStatusRejReason[] = {  {&_swigt__p_FIX__TradSesStatusRejReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradSesUpdateAction[] = {  {&_swigt__p_FIX__TradSesUpdateAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeAllocIndicator[] = {  {&_swigt__p_FIX__TradeAllocIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeCondition[] = {  {&_swigt__p_FIX__TradeCondition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeDate[] = {  {&_swigt__p_FIX__TradeDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeHandlingInstr[] = {  {&_swigt__p_FIX__TradeHandlingInstr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeID[] = {  {&_swigt__p_FIX__TradeID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeInputDevice[] = {  {&_swigt__p_FIX__TradeInputDevice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeInputSource[] = {  {&_swigt__p_FIX__TradeInputSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeLegRefID[] = {  {&_swigt__p_FIX__TradeLegRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeLinkID[] = {  {&_swigt__p_FIX__TradeLinkID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeOriginationDate[] = {  {&_swigt__p_FIX__TradeOriginationDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradePublishIndicator[] = {  {&_swigt__p_FIX__TradePublishIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportID[] = {  {&_swigt__p_FIX__TradeReportID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportRefID[] = {  {&_swigt__p_FIX__TradeReportRefID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportRejectReason[] = {  {&_swigt__p_FIX__TradeReportRejectReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportTransType[] = {  {&_swigt__p_FIX__TradeReportTransType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeReportType[] = {  {&_swigt__p_FIX__TradeReportType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeRequestID[] = {  {&_swigt__p_FIX__TradeRequestID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeRequestResult[] = {  {&_swigt__p_FIX__TradeRequestResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeRequestStatus[] = {  {&_swigt__p_FIX__TradeRequestStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeRequestType[] = {  {&_swigt__p_FIX__TradeRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeType[] = {  {&_swigt__p_FIX__TradeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradeVolume[] = {  {&_swigt__p_FIX__TradeVolume, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradedFlatSwitch[] = {  {&_swigt__p_FIX__TradedFlatSwitch, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingCurrency[] = {  {&_swigt__p_FIX__TradingCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingReferencePrice[] = {  {&_swigt__p_FIX__TradingReferencePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingSessionDesc[] = {  {&_swigt__p_FIX__TradingSessionDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingSessionID[] = {  {&_swigt__p_FIX__TradingSessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TradingSessionSubID[] = {  {&_swigt__p_FIX__TradingSessionSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Trailer[] = {  {&_swigt__p_FIX__Trailer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TransBkdTime[] = {  {&_swigt__p_FIX__TransBkdTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TransactTime[] = {  {&_swigt__p_FIX__TransactTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TransferReason[] = {  {&_swigt__p_FIX__TransferReason, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdMatchID[] = {  {&_swigt__p_FIX__TrdMatchID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRegTimestamp[] = {  {&_swigt__p_FIX__TrdRegTimestamp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRegTimestampOrigin[] = {  {&_swigt__p_FIX__TrdRegTimestampOrigin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRegTimestampType[] = {  {&_swigt__p_FIX__TrdRegTimestampType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRepIndicator[] = {  {&_swigt__p_FIX__TrdRepIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRepPartyRole[] = {  {&_swigt__p_FIX__TrdRepPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdRptStatus[] = {  {&_swigt__p_FIX__TrdRptStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdSubType[] = {  {&_swigt__p_FIX__TrdSubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TrdType[] = {  {&_swigt__p_FIX__TrdType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerAction[] = {  {&_swigt__p_FIX__TriggerAction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerNewPrice[] = {  {&_swigt__p_FIX__TriggerNewPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerNewQty[] = {  {&_swigt__p_FIX__TriggerNewQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerOrderType[] = {  {&_swigt__p_FIX__TriggerOrderType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerPrice[] = {  {&_swigt__p_FIX__TriggerPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerPriceDirection[] = {  {&_swigt__p_FIX__TriggerPriceDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerPriceType[] = {  {&_swigt__p_FIX__TriggerPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerPriceTypeScope[] = {  {&_swigt__p_FIX__TriggerPriceTypeScope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerSecurityDesc[] = {  {&_swigt__p_FIX__TriggerSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerSecurityID[] = {  {&_swigt__p_FIX__TriggerSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerSecurityIDSource[] = {  {&_swigt__p_FIX__TriggerSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerSymbol[] = {  {&_swigt__p_FIX__TriggerSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerTradingSessionID[] = {  {&_swigt__p_FIX__TriggerTradingSessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerTradingSessionSubID[] = {  {&_swigt__p_FIX__TriggerTradingSessionSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__TriggerType[] = {  {&_swigt__p_FIX__TriggerType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__URLLink[] = {  {&_swigt__p_FIX__URLLink, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UTCDATE[] = {  {&_swigt__p_FIX__UTCDATE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UTCDATEONLY[] = {  {&_swigt__p_FIX__UTCDATEONLY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UTCTIMEONLY[] = {  {&_swigt__p_FIX__UTCTIMEONLY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UTCTIMESTAMP[] = {  {&_swigt__p_FIX__UTCTIMESTAMP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingAdjustedQuantity[] = {  {&_swigt__p_FIX__UnderlyingAdjustedQuantity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingAllocationPercent[] = {  {&_swigt__p_FIX__UnderlyingAllocationPercent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingAttachmentPoint[] = {  {&_swigt__p_FIX__UnderlyingAttachmentPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCFICode[] = {  {&_swigt__p_FIX__UnderlyingCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCPProgram[] = {  {&_swigt__p_FIX__UnderlyingCPProgram, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCPRegType[] = {  {&_swigt__p_FIX__UnderlyingCPRegType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCapValue[] = {  {&_swigt__p_FIX__UnderlyingCapValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCashAmount[] = {  {&_swigt__p_FIX__UnderlyingCashAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCashType[] = {  {&_swigt__p_FIX__UnderlyingCashType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCollectAmount[] = {  {&_swigt__p_FIX__UnderlyingCollectAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingContractMultiplier[] = {  {&_swigt__p_FIX__UnderlyingContractMultiplier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingContractMultiplierUnit[] = {  {&_swigt__p_FIX__UnderlyingContractMultiplierUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCountryOfIssue[] = {  {&_swigt__p_FIX__UnderlyingCountryOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCouponPaymentDate[] = {  {&_swigt__p_FIX__UnderlyingCouponPaymentDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCouponRate[] = {  {&_swigt__p_FIX__UnderlyingCouponRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCreditRating[] = {  {&_swigt__p_FIX__UnderlyingCreditRating, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCurrency[] = {  {&_swigt__p_FIX__UnderlyingCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingCurrentValue[] = {  {&_swigt__p_FIX__UnderlyingCurrentValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingDeliveryAmount[] = {  {&_swigt__p_FIX__UnderlyingDeliveryAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingDetachmentPoint[] = {  {&_swigt__p_FIX__UnderlyingDetachmentPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingDirtyPrice[] = {  {&_swigt__p_FIX__UnderlyingDirtyPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingEndPrice[] = {  {&_swigt__p_FIX__UnderlyingEndPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingEndValue[] = {  {&_swigt__p_FIX__UnderlyingEndValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingExerciseStyle[] = {  {&_swigt__p_FIX__UnderlyingExerciseStyle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingFXRate[] = {  {&_swigt__p_FIX__UnderlyingFXRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingFXRateCalc[] = {  {&_swigt__p_FIX__UnderlyingFXRateCalc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingFactor[] = {  {&_swigt__p_FIX__UnderlyingFactor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingFlowScheduleType[] = {  {&_swigt__p_FIX__UnderlyingFlowScheduleType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingIDSource[] = {  {&_swigt__p_FIX__UnderlyingIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrRegistry[] = {  {&_swigt__p_FIX__UnderlyingInstrRegistry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartyID[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartyIDSource[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartyRole[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartySubID[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingInstrumentPartySubIDType[] = {  {&_swigt__p_FIX__UnderlyingInstrumentPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingIssueDate[] = {  {&_swigt__p_FIX__UnderlyingIssueDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingIssuer[] = {  {&_swigt__p_FIX__UnderlyingIssuer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLastPx[] = {  {&_swigt__p_FIX__UnderlyingLastPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLastQty[] = {  {&_swigt__p_FIX__UnderlyingLastQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegCFICode[] = {  {&_swigt__p_FIX__UnderlyingLegCFICode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegMaturityDate[] = {  {&_swigt__p_FIX__UnderlyingLegMaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegMaturityMonthYear[] = {  {&_swigt__p_FIX__UnderlyingLegMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegMaturityTime[] = {  {&_swigt__p_FIX__UnderlyingLegMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegOptAttribute[] = {  {&_swigt__p_FIX__UnderlyingLegOptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegPutOrCall[] = {  {&_swigt__p_FIX__UnderlyingLegPutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityAltID[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityAltIDSource[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityDesc[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityExchange[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityID[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityIDSource[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecuritySubType[] = {  {&_swigt__p_FIX__UnderlyingLegSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSecurityType[] = {  {&_swigt__p_FIX__UnderlyingLegSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegStrikePrice[] = {  {&_swigt__p_FIX__UnderlyingLegStrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSymbol[] = {  {&_swigt__p_FIX__UnderlyingLegSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLegSymbolSfx[] = {  {&_swigt__p_FIX__UnderlyingLegSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingLocaleOfIssue[] = {  {&_swigt__p_FIX__UnderlyingLocaleOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingMaturityDate[] = {  {&_swigt__p_FIX__UnderlyingMaturityDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingMaturityDay[] = {  {&_swigt__p_FIX__UnderlyingMaturityDay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingMaturityMonthYear[] = {  {&_swigt__p_FIX__UnderlyingMaturityMonthYear, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingMaturityTime[] = {  {&_swigt__p_FIX__UnderlyingMaturityTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingNotionalPercentageOutstanding[] = {  {&_swigt__p_FIX__UnderlyingNotionalPercentageOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingOptAttribute[] = {  {&_swigt__p_FIX__UnderlyingOptAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding[] = {  {&_swigt__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPayAmount[] = {  {&_swigt__p_FIX__UnderlyingPayAmount, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPriceDeterminationMethod[] = {  {&_swigt__p_FIX__UnderlyingPriceDeterminationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPriceUnitOfMeasure[] = {  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPriceUnitOfMeasureQty[] = {  {&_swigt__p_FIX__UnderlyingPriceUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingProduct[] = {  {&_swigt__p_FIX__UnderlyingProduct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPutOrCall[] = {  {&_swigt__p_FIX__UnderlyingPutOrCall, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingPx[] = {  {&_swigt__p_FIX__UnderlyingPx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingQty[] = {  {&_swigt__p_FIX__UnderlyingQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRedemptionDate[] = {  {&_swigt__p_FIX__UnderlyingRedemptionDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRepoCollateralSecurityType[] = {  {&_swigt__p_FIX__UnderlyingRepoCollateralSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRepurchaseRate[] = {  {&_swigt__p_FIX__UnderlyingRepurchaseRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRepurchaseTerm[] = {  {&_swigt__p_FIX__UnderlyingRepurchaseTerm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingRestructuringType[] = {  {&_swigt__p_FIX__UnderlyingRestructuringType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityAltID[] = {  {&_swigt__p_FIX__UnderlyingSecurityAltID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityAltIDSource[] = {  {&_swigt__p_FIX__UnderlyingSecurityAltIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityDesc[] = {  {&_swigt__p_FIX__UnderlyingSecurityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityExchange[] = {  {&_swigt__p_FIX__UnderlyingSecurityExchange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityID[] = {  {&_swigt__p_FIX__UnderlyingSecurityID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityIDSource[] = {  {&_swigt__p_FIX__UnderlyingSecurityIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecuritySubType[] = {  {&_swigt__p_FIX__UnderlyingSecuritySubType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSecurityType[] = {  {&_swigt__p_FIX__UnderlyingSecurityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSeniority[] = {  {&_swigt__p_FIX__UnderlyingSeniority, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlMethod[] = {  {&_swigt__p_FIX__UnderlyingSettlMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlPrice[] = {  {&_swigt__p_FIX__UnderlyingSettlPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlPriceType[] = {  {&_swigt__p_FIX__UnderlyingSettlPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlementDate[] = {  {&_swigt__p_FIX__UnderlyingSettlementDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlementStatus[] = {  {&_swigt__p_FIX__UnderlyingSettlementStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSettlementType[] = {  {&_swigt__p_FIX__UnderlyingSettlementType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStartValue[] = {  {&_swigt__p_FIX__UnderlyingStartValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStateOrProvinceOfIssue[] = {  {&_swigt__p_FIX__UnderlyingStateOrProvinceOfIssue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStipType[] = {  {&_swigt__p_FIX__UnderlyingStipType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStipValue[] = {  {&_swigt__p_FIX__UnderlyingStipValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStrikeCurrency[] = {  {&_swigt__p_FIX__UnderlyingStrikeCurrency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingStrikePrice[] = {  {&_swigt__p_FIX__UnderlyingStrikePrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSymbol[] = {  {&_swigt__p_FIX__UnderlyingSymbol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingSymbolSfx[] = {  {&_swigt__p_FIX__UnderlyingSymbolSfx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingTimeUnit[] = {  {&_swigt__p_FIX__UnderlyingTimeUnit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingTradingSessionID[] = {  {&_swigt__p_FIX__UnderlyingTradingSessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingTradingSessionSubID[] = {  {&_swigt__p_FIX__UnderlyingTradingSessionSubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingUnitOfMeasure[] = {  {&_swigt__p_FIX__UnderlyingUnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnderlyingUnitOfMeasureQty[] = {  {&_swigt__p_FIX__UnderlyingUnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartyID[] = {  {&_swigt__p_FIX__UndlyInstrumentPartyID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartyIDSource[] = {  {&_swigt__p_FIX__UndlyInstrumentPartyIDSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartyRole[] = {  {&_swigt__p_FIX__UndlyInstrumentPartyRole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartySubID[] = {  {&_swigt__p_FIX__UndlyInstrumentPartySubID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UndlyInstrumentPartySubIDType[] = {  {&_swigt__p_FIX__UndlyInstrumentPartySubIDType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnitOfMeasure[] = {  {&_swigt__p_FIX__UnitOfMeasure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnitOfMeasureQty[] = {  {&_swigt__p_FIX__UnitOfMeasureQty, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnsolicitedIndicator[] = {  {&_swigt__p_FIX__UnsolicitedIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnsupportedMessageType[] = {  {&_swigt__p_FIX__UnsupportedMessageType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UnsupportedVersion[] = {  {&_swigt__p_FIX__UnsupportedVersion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Urgency[] = {  {&_swigt__p_FIX__Urgency, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UserRequestID[] = {  {&_swigt__p_FIX__UserRequestID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UserRequestType[] = {  {&_swigt__p_FIX__UserRequestType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UserStatus[] = {  {&_swigt__p_FIX__UserStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UserStatusText[] = {  {&_swigt__p_FIX__UserStatusText, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Username[] = {  {&_swigt__p_FIX__Username, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UtcDateField[] = {  {&_swigt__p_FIX__UtcDateField, 0, 0, 0},  {&_swigt__p_FIX__MDEntryDate, _p_FIX__MDEntryDateTo_p_FIX__UtcDateField, 0, 0},  {&_swigt__p_FIX__TotalVolumeTradedDate, _p_FIX__TotalVolumeTradedDateTo_p_FIX__UtcDateField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UtcTimeOnlyField[] = {  {&_swigt__p_FIX__UtcTimeOnlyField, 0, 0, 0},  {&_swigt__p_FIX__MDEntryTime, _p_FIX__MDEntryTimeTo_p_FIX__UtcTimeOnlyField, 0, 0},  {&_swigt__p_FIX__ComplexEventStartTime, _p_FIX__ComplexEventStartTimeTo_p_FIX__UtcTimeOnlyField, 0, 0},  {&_swigt__p_FIX__TotalVolumeTradedTime, _p_FIX__TotalVolumeTradedTimeTo_p_FIX__UtcTimeOnlyField, 0, 0},  {&_swigt__p_FIX__ComplexEventEndTime, _p_FIX__ComplexEventEndTimeTo_p_FIX__UtcTimeOnlyField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__UtcTimeStampField[] = {  {&_swigt__p_FIX__TradSesEndTime, _p_FIX__TradSesEndTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__OrigTime, _p_FIX__OrigTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__DerivativeEventTime, _p_FIX__DerivativeEventTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__EventTime, _p_FIX__EventTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__OrigOrdModTime, _p_FIX__OrigOrdModTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TradSesOpenTime, _p_FIX__TradSesOpenTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__UtcTimeStampField, 0, 0, 0},  {&_swigt__p_FIX__ExecValuationPoint, _p_FIX__ExecValuationPointTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ComplexEventStartDate, _p_FIX__ComplexEventStartDateTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__SideTimeInForce, _p_FIX__SideTimeInForceTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ExpireTime, _p_FIX__ExpireTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TransBkdTime, _p_FIX__TransBkdTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TradSesPreCloseTime, _p_FIX__TradSesPreCloseTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TradSesCloseTime, _p_FIX__TradSesCloseTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TradSesStartTime, _p_FIX__TradSesStartTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__StrikeTime, _p_FIX__StrikeTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__LastUpdateTime, _p_FIX__LastUpdateTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__QuoteSetValidUntilTime, _p_FIX__QuoteSetValidUntilTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ValidUntilTime, _p_FIX__ValidUntilTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__RelSymTransactTime, _p_FIX__RelSymTransactTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__SideTrdRegTimestamp, _p_FIX__SideTrdRegTimestampTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ContraTradeTime, _p_FIX__ContraTradeTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TransactTime, _p_FIX__TransactTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__TrdRegTimestamp, _p_FIX__TrdRegTimestampTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__OrigSendingTime, _p_FIX__OrigSendingTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__ComplexEventEndDate, _p_FIX__ComplexEventEndDateTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__HopSendingTime, _p_FIX__HopSendingTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__OnBehalfOfSendingTime, _p_FIX__OnBehalfOfSendingTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__SendingTime, _p_FIX__SendingTimeTo_p_FIX__UtcTimeStampField, 0, 0},  {&_swigt__p_FIX__EffectiveTime, _p_FIX__EffectiveTimeTo_p_FIX__UtcTimeStampField, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ValidUntilTime[] = {  {&_swigt__p_FIX__ValidUntilTime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ValuationMethod[] = {  {&_swigt__p_FIX__ValuationMethod, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__ValueOfFutures[] = {  {&_swigt__p_FIX__ValueOfFutures, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__VenueType[] = {  {&_swigt__p_FIX__VenueType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Volatility[] = {  {&_swigt__p_FIX__Volatility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__WaveNo[] = {  {&_swigt__p_FIX__WaveNo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__WorkingIndicator[] = {  {&_swigt__p_FIX__WorkingIndicator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__WtAverageLiquidity[] = {  {&_swigt__p_FIX__WtAverageLiquidity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__XMLDATA[] = {  {&_swigt__p_FIX__XMLDATA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__XmlData[] = {  {&_swigt__p_FIX__XmlData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__XmlDataLen[] = {  {&_swigt__p_FIX__XmlDataLen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__Yield[] = {  {&_swigt__p_FIX__Yield, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldCalcDate[] = {  {&_swigt__p_FIX__YieldCalcDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldRedemptionDate[] = {  {&_swigt__p_FIX__YieldRedemptionDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldRedemptionPrice[] = {  {&_swigt__p_FIX__YieldRedemptionPrice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldRedemptionPriceType[] = {  {&_swigt__p_FIX__YieldRedemptionPriceType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FIX__YieldType[] = {  {&_swigt__p_FIX__YieldType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Fields[] = {  {&_swigt__p_Fields, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Group[] = {  {&_swigt__p_Group, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Groups[] = {  {&_swigt__p_Groups, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IntArray[] = {  {&_swigt__p_IntArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IntField[] = {  {&_swigt__p_IntField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Log[] = {  {&_swigt__p_Log, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LogFactory[] = {  {&_swigt__p_LogFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MessageStore[] = {  {&_swigt__p_MessageStore, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MessageStoreFactory[] = {  {&_swigt__p_MessageStoreFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MsgType[] = {  {&_swigt__p_MsgType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Mutex[] = {  {&_swigt__p_Mutex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Responder[] = {  {&_swigt__p_Responder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SessionID[] = {  {&_swigt__p_SessionID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StringField[] = {  {&_swigt__p_StringField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TimeRange[] = {  {&_swigt__p_TimeRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UtcDate[] = {  {&_swigt__p_UtcDate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UtcDateField[] = {  {&_swigt__p_UtcDateField, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UtcTimeOnly[] = {  {&_swigt__p_UtcTimeOnly, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UtcTimeStamp[] = {  {&_swigt__p_UtcTimeStamp, 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_const_iterator[] = {  {&_swigt__p_const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_g_const_iterator[] = {  {&_swigt__p_g_const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_g_iterator[] = {  {&_swigt__p_g_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_IntArray, _p_IntArrayTo_p_int, 0, 0},  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iterator[] = {  {&_swigt__p_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_message_order[] = {  {&_swigt__p_message_order, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_FIX__DataDictionary[] = {  {&_swigt__p_p_FIX__DataDictionary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__istream[] = {  {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ostream[] = {  {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__setT_FIX__SessionID_t[] = {  {&_swigt__p_std__setT_FIX__SessionID_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_std__string_t[] = {  {&_swigt__p_std__vectorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_ApplVerID,
  _swigc__p_Application,
  _swigc__p_BeginString,
  _swigc__p_DOMDocumentPtr,
  _swigc__p_Data,
  _swigc__p_DataDictionary,
  _swigc__p_DataDictionaryProvider,
  _swigc__p_Dictionaries,
  _swigc__p_DoubleField,
  _swigc__p_FIX__AMT,
  _swigc__p_FIX__Acceptor,
  _swigc__p_FIX__Account,
  _swigc__p_FIX__AccountType,
  _swigc__p_FIX__AccruedInterestAmt,
  _swigc__p_FIX__AccruedInterestRate,
  _swigc__p_FIX__AcctIDSource,
  _swigc__p_FIX__Adjustment,
  _swigc__p_FIX__AdjustmentType,
  _swigc__p_FIX__AdvId,
  _swigc__p_FIX__AdvRefID,
  _swigc__p_FIX__AdvSide,
  _swigc__p_FIX__AdvTransType,
  _swigc__p_FIX__AffectedOrderID,
  _swigc__p_FIX__AffectedSecondaryOrderID,
  _swigc__p_FIX__AffirmStatus,
  _swigc__p_FIX__AggregatedBook,
  _swigc__p_FIX__AggressorIndicator,
  _swigc__p_FIX__AgreementCurrency,
  _swigc__p_FIX__AgreementDate,
  _swigc__p_FIX__AgreementDesc,
  _swigc__p_FIX__AgreementID,
  _swigc__p_FIX__AllocAccount,
  _swigc__p_FIX__AllocAccountType,
  _swigc__p_FIX__AllocAccruedInterestAmt,
  _swigc__p_FIX__AllocAcctIDSource,
  _swigc__p_FIX__AllocAvgPx,
  _swigc__p_FIX__AllocCancReplaceReason,
  _swigc__p_FIX__AllocClearingFeeIndicator,
  _swigc__p_FIX__AllocCustomerCapacity,
  _swigc__p_FIX__AllocHandlInst,
  _swigc__p_FIX__AllocID,
  _swigc__p_FIX__AllocInterestAtMaturity,
  _swigc__p_FIX__AllocIntermedReqType,
  _swigc__p_FIX__AllocLinkID,
  _swigc__p_FIX__AllocLinkType,
  _swigc__p_FIX__AllocMethod,
  _swigc__p_FIX__AllocNetMoney,
  _swigc__p_FIX__AllocNoOrdersType,
  _swigc__p_FIX__AllocPositionEffect,
  _swigc__p_FIX__AllocPrice,
  _swigc__p_FIX__AllocQty,
  _swigc__p_FIX__AllocRejCode,
  _swigc__p_FIX__AllocReportID,
  _swigc__p_FIX__AllocReportRefID,
  _swigc__p_FIX__AllocReportType,
  _swigc__p_FIX__AllocSettlCurrAmt,
  _swigc__p_FIX__AllocSettlCurrency,
  _swigc__p_FIX__AllocSettlInstType,
  _swigc__p_FIX__AllocShares,
  _swigc__p_FIX__AllocStatus,
  _swigc__p_FIX__AllocText,
  _swigc__p_FIX__AllocTransType,
  _swigc__p_FIX__AllocType,
  _swigc__p_FIX__AllowableOneSidednessCurr,
  _swigc__p_FIX__AllowableOneSidednessPct,
  _swigc__p_FIX__AllowableOneSidednessValue,
  _swigc__p_FIX__AltMDSourceID,
  _swigc__p_FIX__ApplBegSeqNum,
  _swigc__p_FIX__ApplEndSeqNum,
  _swigc__p_FIX__ApplExtID,
  _swigc__p_FIX__ApplID,
  _swigc__p_FIX__ApplLastSeqNum,
  _swigc__p_FIX__ApplNewSeqNum,
  _swigc__p_FIX__ApplQueueAction,
  _swigc__p_FIX__ApplQueueDepth,
  _swigc__p_FIX__ApplQueueMax,
  _swigc__p_FIX__ApplQueueResolution,
  _swigc__p_FIX__ApplReportID,
  _swigc__p_FIX__ApplReportType,
  _swigc__p_FIX__ApplReqID,
  _swigc__p_FIX__ApplReqType,
  _swigc__p_FIX__ApplResendFlag,
  _swigc__p_FIX__ApplResponseError,
  _swigc__p_FIX__ApplResponseID,
  _swigc__p_FIX__ApplResponseType,
  _swigc__p_FIX__ApplSeqNum,
  _swigc__p_FIX__ApplTotalMessageCount,
  _swigc__p_FIX__ApplVerID,
  _swigc__p_FIX__Application,
  _swigc__p_FIX__AsOfIndicator,
  _swigc__p_FIX__AsgnRptID,
  _swigc__p_FIX__AssignmentMethod,
  _swigc__p_FIX__AssignmentUnit,
  _swigc__p_FIX__AttachmentPoint,
  _swigc__p_FIX__AutoAcceptIndicator,
  _swigc__p_FIX__AvgParPx,
  _swigc__p_FIX__AvgPrxPrecision,
  _swigc__p_FIX__AvgPx,
  _swigc__p_FIX__AvgPxIndicator,
  _swigc__p_FIX__AvgPxPrecision,
  _swigc__p_FIX__BOOLEAN,
  _swigc__p_FIX__BasisFeatureDate,
  _swigc__p_FIX__BasisFeaturePrice,
  _swigc__p_FIX__BasisPxType,
  _swigc__p_FIX__BeginSeqNo,
  _swigc__p_FIX__BeginString,
  _swigc__p_FIX__Benchmark,
  _swigc__p_FIX__BenchmarkCurveCurrency,
  _swigc__p_FIX__BenchmarkCurveName,
  _swigc__p_FIX__BenchmarkCurvePoint,
  _swigc__p_FIX__BenchmarkPrice,
  _swigc__p_FIX__BenchmarkPriceType,
  _swigc__p_FIX__BenchmarkSecurityID,
  _swigc__p_FIX__BenchmarkSecurityIDSource,
  _swigc__p_FIX__BidDescriptor,
  _swigc__p_FIX__BidDescriptorType,
  _swigc__p_FIX__BidForwardPoints,
  _swigc__p_FIX__BidForwardPoints2,
  _swigc__p_FIX__BidID,
  _swigc__p_FIX__BidPx,
  _swigc__p_FIX__BidRequestTransType,
  _swigc__p_FIX__BidSize,
  _swigc__p_FIX__BidSpotRate,
  _swigc__p_FIX__BidSwapPoints,
  _swigc__p_FIX__BidTradeType,
  _swigc__p_FIX__BidType,
  _swigc__p_FIX__BidYield,
  _swigc__p_FIX__BodyLength,
  _swigc__p_FIX__BookingRefID,
  _swigc__p_FIX__BookingType,
  _swigc__p_FIX__BookingUnit,
  _swigc__p_FIX__BoolField,
  _swigc__p_FIX__BrokerOfCredit,
  _swigc__p_FIX__BusinessRejectReason,
  _swigc__p_FIX__BusinessRejectRefID,
  _swigc__p_FIX__BuyVolume,
  _swigc__p_FIX__CFICode,
  _swigc__p_FIX__CHAR,
  _swigc__p_FIX__COUNTRY,
  _swigc__p_FIX__CPProgram,
  _swigc__p_FIX__CPRegType,
  _swigc__p_FIX__CURRENCY,
  _swigc__p_FIX__CalculatedCcyLastQty,
  _swigc__p_FIX__CancellationRights,
  _swigc__p_FIX__CapPrice,
  _swigc__p_FIX__CardExpDate,
  _swigc__p_FIX__CardHolderName,
  _swigc__p_FIX__CardIssNo,
  _swigc__p_FIX__CardIssNum,
  _swigc__p_FIX__CardNumber,
  _swigc__p_FIX__CardStartDate,
  _swigc__p_FIX__CashDistribAgentAcctName,
  _swigc__p_FIX__CashDistribAgentAcctNumber,
  _swigc__p_FIX__CashDistribAgentCode,
  _swigc__p_FIX__CashDistribAgentName,
  _swigc__p_FIX__CashDistribCurr,
  _swigc__p_FIX__CashDistribPayRef,
  _swigc__p_FIX__CashMargin,
  _swigc__p_FIX__CashOrderQty,
  _swigc__p_FIX__CashOutstanding,
  _swigc__p_FIX__CashSettlAgentAcctName,
  _swigc__p_FIX__CashSettlAgentAcctNum,
  _swigc__p_FIX__CashSettlAgentCode,
  _swigc__p_FIX__CashSettlAgentContactName,
  _swigc__p_FIX__CashSettlAgentContactPhone,
  _swigc__p_FIX__CashSettlAgentName,
  _swigc__p_FIX__CcyAmt,
  _swigc__p_FIX__CharField,
  _swigc__p_FIX__CheckSum,
  _swigc__p_FIX__CheckSumField,
  _swigc__p_FIX__ClOrdID,
  _swigc__p_FIX__ClOrdLinkID,
  _swigc__p_FIX__ClearingAccount,
  _swigc__p_FIX__ClearingBusinessDate,
  _swigc__p_FIX__ClearingFeeIndicator,
  _swigc__p_FIX__ClearingFirm,
  _swigc__p_FIX__ClearingInstruction,
  _swigc__p_FIX__ClientBidID,
  _swigc__p_FIX__ClientID,
  _swigc__p_FIX__CollAction,
  _swigc__p_FIX__CollApplType,
  _swigc__p_FIX__CollAsgnID,
  _swigc__p_FIX__CollAsgnReason,
  _swigc__p_FIX__CollAsgnRefID,
  _swigc__p_FIX__CollAsgnRejectReason,
  _swigc__p_FIX__CollAsgnRespType,
  _swigc__p_FIX__CollAsgnTransType,
  _swigc__p_FIX__CollInquiryID,
  _swigc__p_FIX__CollInquiryQualifier,
  _swigc__p_FIX__CollInquiryResult,
  _swigc__p_FIX__CollInquiryStatus,
  _swigc__p_FIX__CollReqID,
  _swigc__p_FIX__CollRespID,
  _swigc__p_FIX__CollRptID,
  _swigc__p_FIX__CollStatus,
  _swigc__p_FIX__CommCurrency,
  _swigc__p_FIX__CommType,
  _swigc__p_FIX__Commission,
  _swigc__p_FIX__ComplexEventCondition,
  _swigc__p_FIX__ComplexEventEndDate,
  _swigc__p_FIX__ComplexEventEndTime,
  _swigc__p_FIX__ComplexEventPrice,
  _swigc__p_FIX__ComplexEventPriceBoundaryMethod,
  _swigc__p_FIX__ComplexEventPriceBoundaryPrecision,
  _swigc__p_FIX__ComplexEventPriceTimeType,
  _swigc__p_FIX__ComplexEventStartDate,
  _swigc__p_FIX__ComplexEventStartTime,
  _swigc__p_FIX__ComplexEventType,
  _swigc__p_FIX__ComplexOptPayoutAmount,
  _swigc__p_FIX__ComplianceID,
  _swigc__p_FIX__Concession,
  _swigc__p_FIX__ConfigError,
  _swigc__p_FIX__ConfirmID,
  _swigc__p_FIX__ConfirmRefID,
  _swigc__p_FIX__ConfirmRejReason,
  _swigc__p_FIX__ConfirmReqID,
  _swigc__p_FIX__ConfirmStatus,
  _swigc__p_FIX__ConfirmTransType,
  _swigc__p_FIX__ConfirmType,
  _swigc__p_FIX__ContAmtCurr,
  _swigc__p_FIX__ContAmtType,
  _swigc__p_FIX__ContAmtValue,
  _swigc__p_FIX__ContIntRptID,
  _swigc__p_FIX__ContingencyType,
  _swigc__p_FIX__ContraBroker,
  _swigc__p_FIX__ContraLegRefID,
  _swigc__p_FIX__ContraTradeQty,
  _swigc__p_FIX__ContraTradeTime,
  _swigc__p_FIX__ContraTrader,
  _swigc__p_FIX__ContractMultiplier,
  _swigc__p_FIX__ContractMultiplierUnit,
  _swigc__p_FIX__ContractSettlMonth,
  _swigc__p_FIX__ContraryInstructionIndicator,
  _swigc__p_FIX__CopyMsgIndicator,
  _swigc__p_FIX__CorporateAction,
  _swigc__p_FIX__Country,
  _swigc__p_FIX__CountryOfIssue,
  _swigc__p_FIX__CouponPaymentDate,
  _swigc__p_FIX__CouponRate,
  _swigc__p_FIX__CoveredOrUncovered,
  _swigc__p_FIX__CreditRating,
  _swigc__p_FIX__CrossID,
  _swigc__p_FIX__CrossPercent,
  _swigc__p_FIX__CrossPrioritization,
  _swigc__p_FIX__CrossType,
  _swigc__p_FIX__CstmApplVerID,
  _swigc__p_FIX__CumQty,
  _swigc__p_FIX__Currency,
  _swigc__p_FIX__CurrencyRatio,
  _swigc__p_FIX__CustDirectedOrder,
  _swigc__p_FIX__CustOrderCapacity,
  _swigc__p_FIX__CustOrderHandlingInst,
  _swigc__p_FIX__CustomerOrFirm,
  _swigc__p_FIX__CxlQty,
  _swigc__p_FIX__CxlRejReason,
  _swigc__p_FIX__CxlRejResponseTo,
  _swigc__p_FIX__CxlType,
  _swigc__p_FIX__DATA,
  _swigc__p_FIX__DAYOFMONTH,
  _swigc__p_FIX__DKReason,
  _swigc__p_FIX__DataDictionary,
  _swigc__p_FIX__DataDictionaryNotFound,
  _swigc__p_FIX__DateOfBirth,
  _swigc__p_FIX__DatedDate,
  _swigc__p_FIX__DayAvgPx,
  _swigc__p_FIX__DayBookingInst,
  _swigc__p_FIX__DayCumQty,
  _swigc__p_FIX__DayOrderQty,
  _swigc__p_FIX__DealingCapacity,
  _swigc__p_FIX__DefBidSize,
  _swigc__p_FIX__DefOfferSize,
  _swigc__p_FIX__DefaultApplExtID,
  _swigc__p_FIX__DefaultApplVerID,
  _swigc__p_FIX__DefaultCstmApplVerID,
  _swigc__p_FIX__DefaultVerIndicator,
  _swigc__p_FIX__DeleteReason,
  _swigc__p_FIX__DeliverToCompID,
  _swigc__p_FIX__DeliverToLocationID,
  _swigc__p_FIX__DeliverToSubID,
  _swigc__p_FIX__DeliveryDate,
  _swigc__p_FIX__DeliveryForm,
  _swigc__p_FIX__DeliveryType,
  _swigc__p_FIX__DerivFlexProductEligibilityIndicator,
  _swigc__p_FIX__DerivativeCFICode,
  _swigc__p_FIX__DerivativeCapPrice,
  _swigc__p_FIX__DerivativeContractMultiplier,
  _swigc__p_FIX__DerivativeContractMultiplierUnit,
  _swigc__p_FIX__DerivativeContractSettlMonth,
  _swigc__p_FIX__DerivativeCountryOfIssue,
  _swigc__p_FIX__DerivativeEncodedIssuer,
  _swigc__p_FIX__DerivativeEncodedIssuerLen,
  _swigc__p_FIX__DerivativeEncodedSecurityDesc,
  _swigc__p_FIX__DerivativeEncodedSecurityDescLen,
  _swigc__p_FIX__DerivativeEventDate,
  _swigc__p_FIX__DerivativeEventPx,
  _swigc__p_FIX__DerivativeEventText,
  _swigc__p_FIX__DerivativeEventTime,
  _swigc__p_FIX__DerivativeEventType,
  _swigc__p_FIX__DerivativeExerciseStyle,
  _swigc__p_FIX__DerivativeFloorPrice,
  _swigc__p_FIX__DerivativeFlowScheduleType,
  _swigc__p_FIX__DerivativeFuturesValuationMethod,
  _swigc__p_FIX__DerivativeInstrAttribType,
  _swigc__p_FIX__DerivativeInstrAttribValue,
  _swigc__p_FIX__DerivativeInstrRegistry,
  _swigc__p_FIX__DerivativeInstrmtAssignmentMethod,
  _swigc__p_FIX__DerivativeInstrumentPartyID,
  _swigc__p_FIX__DerivativeInstrumentPartyIDSource,
  _swigc__p_FIX__DerivativeInstrumentPartyRole,
  _swigc__p_FIX__DerivativeInstrumentPartySubID,
  _swigc__p_FIX__DerivativeInstrumentPartySubIDType,
  _swigc__p_FIX__DerivativeIssueDate,
  _swigc__p_FIX__DerivativeIssuer,
  _swigc__p_FIX__DerivativeListMethod,
  _swigc__p_FIX__DerivativeLocaleOfIssue,
  _swigc__p_FIX__DerivativeMaturityDate,
  _swigc__p_FIX__DerivativeMaturityMonthYear,
  _swigc__p_FIX__DerivativeMaturityTime,
  _swigc__p_FIX__DerivativeMinPriceIncrement,
  _swigc__p_FIX__DerivativeMinPriceIncrementAmount,
  _swigc__p_FIX__DerivativeNTPositionLimit,
  _swigc__p_FIX__DerivativeOptAttribute,
  _swigc__p_FIX__DerivativeOptPayAmount,
  _swigc__p_FIX__DerivativePositionLimit,
  _swigc__p_FIX__DerivativePriceQuoteMethod,
  _swigc__p_FIX__DerivativePriceUnitOfMeasure,
  _swigc__p_FIX__DerivativePriceUnitOfMeasureQty,
  _swigc__p_FIX__DerivativeProduct,
  _swigc__p_FIX__DerivativeProductComplex,
  _swigc__p_FIX__DerivativePutOrCall,
  _swigc__p_FIX__DerivativeSecurityAltID,
  _swigc__p_FIX__DerivativeSecurityAltIDSource,
  _swigc__p_FIX__DerivativeSecurityDesc,
  _swigc__p_FIX__DerivativeSecurityExchange,
  _swigc__p_FIX__DerivativeSecurityGroup,
  _swigc__p_FIX__DerivativeSecurityID,
  _swigc__p_FIX__DerivativeSecurityIDSource,
  _swigc__p_FIX__DerivativeSecurityStatus,
  _swigc__p_FIX__DerivativeSecuritySubType,
  _swigc__p_FIX__DerivativeSecurityType,
  _swigc__p_FIX__DerivativeSecurityXML,
  _swigc__p_FIX__DerivativeSecurityXMLLen,
  _swigc__p_FIX__DerivativeSecurityXMLSchema,
  _swigc__p_FIX__DerivativeSettlMethod,
  _swigc__p_FIX__DerivativeSettleOnOpenFlag,
  _swigc__p_FIX__DerivativeStateOrProvinceOfIssue,
  _swigc__p_FIX__DerivativeStrikeCurrency,
  _swigc__p_FIX__DerivativeStrikeMultiplier,
  _swigc__p_FIX__DerivativeStrikePrice,
  _swigc__p_FIX__DerivativeStrikeValue,
  _swigc__p_FIX__DerivativeSymbol,
  _swigc__p_FIX__DerivativeSymbolSfx,
  _swigc__p_FIX__DerivativeTimeUnit,
  _swigc__p_FIX__DerivativeUnitOfMeasure,
  _swigc__p_FIX__DerivativeUnitOfMeasureQty,
  _swigc__p_FIX__DerivativeValuationMethod,
  _swigc__p_FIX__Designation,
  _swigc__p_FIX__DeskID,
  _swigc__p_FIX__DeskOrderHandlingInst,
  _swigc__p_FIX__DeskType,
  _swigc__p_FIX__DeskTypeSource,
  _swigc__p_FIX__DetachmentPoint,
  _swigc__p_FIX__Dictionary,
  _swigc__p_FIX__Dictionary__Data__const_iterator,
  _swigc__p_FIX__DiscretionInst,
  _swigc__p_FIX__DiscretionLimitType,
  _swigc__p_FIX__DiscretionMoveType,
  _swigc__p_FIX__DiscretionOffset,
  _swigc__p_FIX__DiscretionOffsetType,
  _swigc__p_FIX__DiscretionOffsetValue,
  _swigc__p_FIX__DiscretionPrice,
  _swigc__p_FIX__DiscretionRoundDirection,
  _swigc__p_FIX__DiscretionScope,
  _swigc__p_FIX__DisplayHighQty,
  _swigc__p_FIX__DisplayLowQty,
  _swigc__p_FIX__DisplayMethod,
  _swigc__p_FIX__DisplayMinIncr,
  _swigc__p_FIX__DisplayQty,
  _swigc__p_FIX__DisplayWhen,
  _swigc__p_FIX__DistribPaymentMethod,
  _swigc__p_FIX__DistribPercentage,
  _swigc__p_FIX__DividendYield,
  _swigc__p_FIX__DlvyInst,
  _swigc__p_FIX__DlvyInstType,
  _swigc__p_FIX__DoNotSend,
  _swigc__p_FIX__DoubleField,
  _swigc__p_FIX__DueToRelated,
  _swigc__p_FIX__DuplicateFieldNumber,
  _swigc__p_FIX__EFPTrackingError,
  _swigc__p_FIX__EXCHANGE,
  _swigc__p_FIX__EffectiveTime,
  _swigc__p_FIX__EmailThreadID,
  _swigc__p_FIX__EmailType,
  _swigc__p_FIX__EncodedAllocText,
  _swigc__p_FIX__EncodedAllocTextLen,
  _swigc__p_FIX__EncodedHeadline,
  _swigc__p_FIX__EncodedHeadlineLen,
  _swigc__p_FIX__EncodedIssuer,
  _swigc__p_FIX__EncodedIssuerLen,
  _swigc__p_FIX__EncodedLegIssuer,
  _swigc__p_FIX__EncodedLegIssuerLen,
  _swigc__p_FIX__EncodedLegSecurityDesc,
  _swigc__p_FIX__EncodedLegSecurityDescLen,
  _swigc__p_FIX__EncodedListExecInst,
  _swigc__p_FIX__EncodedListExecInstLen,
  _swigc__p_FIX__EncodedListStatusText,
  _swigc__p_FIX__EncodedListStatusTextLen,
  _swigc__p_FIX__EncodedMktSegmDesc,
  _swigc__p_FIX__EncodedMktSegmDescLen,
  _swigc__p_FIX__EncodedSecurityDesc,
  _swigc__p_FIX__EncodedSecurityDescLen,
  _swigc__p_FIX__EncodedSecurityListDesc,
  _swigc__p_FIX__EncodedSecurityListDescLen,
  _swigc__p_FIX__EncodedSubject,
  _swigc__p_FIX__EncodedSubjectLen,
  _swigc__p_FIX__EncodedText,
  _swigc__p_FIX__EncodedTextLen,
  _swigc__p_FIX__EncodedUnderlyingIssuer,
  _swigc__p_FIX__EncodedUnderlyingIssuerLen,
  _swigc__p_FIX__EncodedUnderlyingSecurityDesc,
  _swigc__p_FIX__EncodedUnderlyingSecurityDescLen,
  _swigc__p_FIX__EncryptMethod,
  _swigc__p_FIX__EncryptedNewPassword,
  _swigc__p_FIX__EncryptedNewPasswordLen,
  _swigc__p_FIX__EncryptedPassword,
  _swigc__p_FIX__EncryptedPasswordLen,
  _swigc__p_FIX__EncryptedPasswordMethod,
  _swigc__p_FIX__EndAccruedInterestAmt,
  _swigc__p_FIX__EndCash,
  _swigc__p_FIX__EndDate,
  _swigc__p_FIX__EndMaturityMonthYear,
  _swigc__p_FIX__EndSeqNo,
  _swigc__p_FIX__EndStrikePxRange,
  _swigc__p_FIX__EndTickPriceRange,
  _swigc__p_FIX__EventDate,
  _swigc__p_FIX__EventPx,
  _swigc__p_FIX__EventText,
  _swigc__p_FIX__EventTime,
  _swigc__p_FIX__EventType,
  _swigc__p_FIX__ExDate,
  _swigc__p_FIX__ExDestination,
  _swigc__p_FIX__ExDestinationIDSource,
  _swigc__p_FIX__Exception,
  _swigc__p_FIX__ExchangeForPhysical,
  _swigc__p_FIX__ExchangeRule,
  _swigc__p_FIX__ExchangeSpecialInstructions,
  _swigc__p_FIX__ExecAckStatus,
  _swigc__p_FIX__ExecBroker,
  _swigc__p_FIX__ExecID,
  _swigc__p_FIX__ExecInst,
  _swigc__p_FIX__ExecInstValue,
  _swigc__p_FIX__ExecPriceAdjustment,
  _swigc__p_FIX__ExecPriceType,
  _swigc__p_FIX__ExecRefID,
  _swigc__p_FIX__ExecRestatementReason,
  _swigc__p_FIX__ExecTransType,
  _swigc__p_FIX__ExecType,
  _swigc__p_FIX__ExecValuationPoint,
  _swigc__p_FIX__ExerciseMethod,
  _swigc__p_FIX__ExerciseStyle,
  _swigc__p_FIX__ExpQty,
  _swigc__p_FIX__ExpType,
  _swigc__p_FIX__ExpirationCycle,
  _swigc__p_FIX__ExpirationQtyType,
  _swigc__p_FIX__ExpireDate,
  _swigc__p_FIX__ExpireTime,
  _swigc__p_FIX__FLOAT,
  _swigc__p_FIX__Factor,
  _swigc__p_FIX__FairValue,
  _swigc__p_FIX__FeeMultiplier,
  _swigc__p_FIX__FieldBase,
  _swigc__p_FIX__FieldConvertError,
  _swigc__p_FIX__FieldMap,
  _swigc__p_FIX__FieldMap__Fields__const_iterator,
  _swigc__p_FIX__FieldMap__Groups__const_iterator,
  _swigc__p_FIX__FieldNotFound,
  _swigc__p_FIX__FileLog,
  _swigc__p_FIX__FileLogFactory,
  _swigc__p_FIX__FileStore,
  _swigc__p_FIX__FileStoreFactory,
  _swigc__p_FIX__FillExecID,
  _swigc__p_FIX__FillLiquidityInd,
  _swigc__p_FIX__FillPx,
  _swigc__p_FIX__FillQty,
  _swigc__p_FIX__FinancialStatus,
  _swigc__p_FIX__FirmTradeID,
  _swigc__p_FIX__FirstPx,
  _swigc__p_FIX__FlexProductEligibilityIndicator,
  _swigc__p_FIX__FlexibleIndicator,
  _swigc__p_FIX__FloorPrice,
  _swigc__p_FIX__FlowScheduleType,
  _swigc__p_FIX__ForexReq,
  _swigc__p_FIX__FundRenewWaiv,
  _swigc__p_FIX__FutSettDate,
  _swigc__p_FIX__FutSettDate2,
  _swigc__p_FIX__FuturesValuationMethod,
  _swigc__p_FIX__GTBookingInst,
  _swigc__p_FIX__GapFillFlag,
  _swigc__p_FIX__GrossTradeAmt,
  _swigc__p_FIX__Group,
  _swigc__p_FIX__HaltReasonChar,
  _swigc__p_FIX__HaltReasonInt,
  _swigc__p_FIX__HandlInst,
  _swigc__p_FIX__Header,
  _swigc__p_FIX__Headline,
  _swigc__p_FIX__HeartBtInt,
  _swigc__p_FIX__HighLimitPrice,
  _swigc__p_FIX__HighPx,
  _swigc__p_FIX__HopCompID,
  _swigc__p_FIX__HopRefID,
  _swigc__p_FIX__HopSendingTime,
  _swigc__p_FIX__HostCrossID,
  _swigc__p_FIX__IDSource,
  _swigc__p_FIX__INT,
  _swigc__p_FIX__IOException,
  _swigc__p_FIX__IOIID,
  _swigc__p_FIX__IOINaturalFlag,
  _swigc__p_FIX__IOIOthSvc,
  _swigc__p_FIX__IOIQltyInd,
  _swigc__p_FIX__IOIQty,
  _swigc__p_FIX__IOIQualifier,
  _swigc__p_FIX__IOIRefID,
  _swigc__p_FIX__IOIShares,
  _swigc__p_FIX__IOITransType,
  _swigc__p_FIX__IOIid,
  _swigc__p_FIX__ImpliedMarketIndicator,
  _swigc__p_FIX__InViewOfCommon,
  _swigc__p_FIX__IncTaxInd,
  _swigc__p_FIX__IncorrectDataFormat,
  _swigc__p_FIX__IncorrectMessageStructure,
  _swigc__p_FIX__IncorrectTagValue,
  _swigc__p_FIX__IndividualAllocID,
  _swigc__p_FIX__IndividualAllocRejCode,
  _swigc__p_FIX__IndividualAllocType,
  _swigc__p_FIX__Initiator,
  _swigc__p_FIX__InputSource,
  _swigc__p_FIX__InstrAttribType,
  _swigc__p_FIX__InstrAttribValue,
  _swigc__p_FIX__InstrRegistry,
  _swigc__p_FIX__InstrmtAssignmentMethod,
  _swigc__p_FIX__InstrumentPartyID,
  _swigc__p_FIX__InstrumentPartyIDSource,
  _swigc__p_FIX__InstrumentPartyRole,
  _swigc__p_FIX__InstrumentPartySubID,
  _swigc__p_FIX__InstrumentPartySubIDType,
  _swigc__p_FIX__IntField,
  _swigc__p_FIX__InterestAccrualDate,
  _swigc__p_FIX__InterestAtMaturity,
  _swigc__p_FIX__InvalidMessage,
  _swigc__p_FIX__InvalidMessageType,
  _swigc__p_FIX__InvalidTagNumber,
  _swigc__p_FIX__InvestorCountryOfResidence,
  _swigc__p_FIX__IssueDate,
  _swigc__p_FIX__Issuer,
  _swigc__p_FIX__LANGUAGE,
  _swigc__p_FIX__LENGTH,
  _swigc__p_FIX__LOCALMKTDATE,
  _swigc__p_FIX__LanguageCode,
  _swigc__p_FIX__LastCapacity,
  _swigc__p_FIX__LastForwardPoints,
  _swigc__p_FIX__LastForwardPoints2,
  _swigc__p_FIX__LastFragment,
  _swigc__p_FIX__LastLiquidityInd,
  _swigc__p_FIX__LastMkt,
  _swigc__p_FIX__LastMsgSeqNumProcessed,
  _swigc__p_FIX__LastNetworkResponseID,
  _swigc__p_FIX__LastParPx,
  _swigc__p_FIX__LastPx,
  _swigc__p_FIX__LastQty,
  _swigc__p_FIX__LastRptRequested,
  _swigc__p_FIX__LastShares,
  _swigc__p_FIX__LastSpotRate,
  _swigc__p_FIX__LastSwapPoints,
  _swigc__p_FIX__LastUpdateTime,
  _swigc__p_FIX__LateIndicator,
  _swigc__p_FIX__LeavesQty,
  _swigc__p_FIX__LegAllocAccount,
  _swigc__p_FIX__LegAllocAcctIDSource,
  _swigc__p_FIX__LegAllocID,
  _swigc__p_FIX__LegAllocQty,
  _swigc__p_FIX__LegAllocSettlCurrency,
  _swigc__p_FIX__LegBenchmarkCurveCurrency,
  _swigc__p_FIX__LegBenchmarkCurveName,
  _swigc__p_FIX__LegBenchmarkCurvePoint,
  _swigc__p_FIX__LegBenchmarkPrice,
  _swigc__p_FIX__LegBenchmarkPriceType,
  _swigc__p_FIX__LegBidForwardPoints,
  _swigc__p_FIX__LegBidPx,
  _swigc__p_FIX__LegCFICode,
  _swigc__p_FIX__LegCalculatedCcyLastQty,
  _swigc__p_FIX__LegContractMultiplier,
  _swigc__p_FIX__LegContractMultiplierUnit,
  _swigc__p_FIX__LegContractSettlMonth,
  _swigc__p_FIX__LegCountryOfIssue,
  _swigc__p_FIX__LegCouponPaymentDate,
  _swigc__p_FIX__LegCouponRate,
  _swigc__p_FIX__LegCoveredOrUncovered,
  _swigc__p_FIX__LegCreditRating,
  _swigc__p_FIX__LegCurrency,
  _swigc__p_FIX__LegCurrencyRatio,
  _swigc__p_FIX__LegDatedDate,
  _swigc__p_FIX__LegDividendYield,
  _swigc__p_FIX__LegExecInst,
  _swigc__p_FIX__LegExerciseStyle,
  _swigc__p_FIX__LegFactor,
  _swigc__p_FIX__LegFlowScheduleType,
  _swigc__p_FIX__LegFutSettDate,
  _swigc__p_FIX__LegGrossTradeAmt,
  _swigc__p_FIX__LegIOIQty,
  _swigc__p_FIX__LegIndividualAllocID,
  _swigc__p_FIX__LegInstrRegistry,
  _swigc__p_FIX__LegInterestAccrualDate,
  _swigc__p_FIX__LegIssueDate,
  _swigc__p_FIX__LegIssuer,
  _swigc__p_FIX__LegLastForwardPoints,
  _swigc__p_FIX__LegLastPx,
  _swigc__p_FIX__LegLastQty,
  _swigc__p_FIX__LegLocaleOfIssue,
  _swigc__p_FIX__LegMaturityDate,
  _swigc__p_FIX__LegMaturityMonthYear,
  _swigc__p_FIX__LegMaturityTime,
  _swigc__p_FIX__LegNumber,
  _swigc__p_FIX__LegOfferForwardPoints,
  _swigc__p_FIX__LegOfferPx,
  _swigc__p_FIX__LegOptAttribute,
  _swigc__p_FIX__LegOptionRatio,
  _swigc__p_FIX__LegOrderQty,
  _swigc__p_FIX__LegPool,
  _swigc__p_FIX__LegPositionEffect,
  _swigc__p_FIX__LegPrice,
  _swigc__p_FIX__LegPriceType,
  _swigc__p_FIX__LegPriceUnitOfMeasure,
  _swigc__p_FIX__LegPriceUnitOfMeasureQty,
  _swigc__p_FIX__LegProduct,
  _swigc__p_FIX__LegPutOrCall,
  _swigc__p_FIX__LegQty,
  _swigc__p_FIX__LegRatioQty,
  _swigc__p_FIX__LegRedemptionDate,
  _swigc__p_FIX__LegRefID,
  _swigc__p_FIX__LegRepoCollateralSecurityType,
  _swigc__p_FIX__LegReportID,
  _swigc__p_FIX__LegRepurchaseRate,
  _swigc__p_FIX__LegRepurchaseTerm,
  _swigc__p_FIX__LegSecurityAltID,
  _swigc__p_FIX__LegSecurityAltIDSource,
  _swigc__p_FIX__LegSecurityDesc,
  _swigc__p_FIX__LegSecurityExchange,
  _swigc__p_FIX__LegSecurityID,
  _swigc__p_FIX__LegSecurityIDSource,
  _swigc__p_FIX__LegSecuritySubType,
  _swigc__p_FIX__LegSecurityType,
  _swigc__p_FIX__LegSettlCurrency,
  _swigc__p_FIX__LegSettlDate,
  _swigc__p_FIX__LegSettlType,
  _swigc__p_FIX__LegSettlmntTyp,
  _swigc__p_FIX__LegSide,
  _swigc__p_FIX__LegStateOrProvinceOfIssue,
  _swigc__p_FIX__LegStipulationType,
  _swigc__p_FIX__LegStipulationValue,
  _swigc__p_FIX__LegStrikeCurrency,
  _swigc__p_FIX__LegStrikePrice,
  _swigc__p_FIX__LegSwapType,
  _swigc__p_FIX__LegSymbol,
  _swigc__p_FIX__LegSymbolSfx,
  _swigc__p_FIX__LegTimeUnit,
  _swigc__p_FIX__LegUnitOfMeasure,
  _swigc__p_FIX__LegUnitOfMeasureQty,
  _swigc__p_FIX__LegVolatility,
  _swigc__p_FIX__LegalConfirm,
  _swigc__p_FIX__LinesOfText,
  _swigc__p_FIX__LiquidityIndType,
  _swigc__p_FIX__LiquidityNumSecurities,
  _swigc__p_FIX__LiquidityPctHigh,
  _swigc__p_FIX__LiquidityPctLow,
  _swigc__p_FIX__LiquidityValue,
  _swigc__p_FIX__ListExecInst,
  _swigc__p_FIX__ListExecInstType,
  _swigc__p_FIX__ListID,
  _swigc__p_FIX__ListMethod,
  _swigc__p_FIX__ListName,
  _swigc__p_FIX__ListNoOrds,
  _swigc__p_FIX__ListOrderStatus,
  _swigc__p_FIX__ListRejectReason,
  _swigc__p_FIX__ListSeqNo,
  _swigc__p_FIX__ListStatusText,
  _swigc__p_FIX__ListStatusType,
  _swigc__p_FIX__ListUpdateAction,
  _swigc__p_FIX__LocaleOfIssue,
  _swigc__p_FIX__LocateReqd,
  _swigc__p_FIX__LocationID,
  _swigc__p_FIX__Log,
  _swigc__p_FIX__LogFactory,
  _swigc__p_FIX__LongQty,
  _swigc__p_FIX__LotType,
  _swigc__p_FIX__LowLimitPrice,
  _swigc__p_FIX__LowPx,
  _swigc__p_FIX__MDBookType,
  _swigc__p_FIX__MDEntryBuyer,
  _swigc__p_FIX__MDEntryDate,
  _swigc__p_FIX__MDEntryForwardPoints,
  _swigc__p_FIX__MDEntryID,
  _swigc__p_FIX__MDEntryOriginator,
  _swigc__p_FIX__MDEntryPositionNo,
  _swigc__p_FIX__MDEntryPx,
  _swigc__p_FIX__MDEntryRefID,
  _swigc__p_FIX__MDEntrySeller,
  _swigc__p_FIX__MDEntrySize,
  _swigc__p_FIX__MDEntrySpotRate,
  _swigc__p_FIX__MDEntryTime,
  _swigc__p_FIX__MDEntryType,
  _swigc__p_FIX__MDFeedType,
  _swigc__p_FIX__MDImplicitDelete,
  _swigc__p_FIX__MDMkt,
  _swigc__p_FIX__MDOriginType,
  _swigc__p_FIX__MDPriceLevel,
  _swigc__p_FIX__MDQuoteType,
  _swigc__p_FIX__MDReportID,
  _swigc__p_FIX__MDReqID,
  _swigc__p_FIX__MDReqRejReason,
  _swigc__p_FIX__MDSecSize,
  _swigc__p_FIX__MDSecSizeType,
  _swigc__p_FIX__MDStreamID,
  _swigc__p_FIX__MDSubBookType,
  _swigc__p_FIX__MDUpdateAction,
  _swigc__p_FIX__MDUpdateType,
  _swigc__p_FIX__MONTHYEAR,
  _swigc__p_FIX__MULTIPLECHARVALUE,
  _swigc__p_FIX__MULTIPLESTRINGVALUE,
  _swigc__p_FIX__MULTIPLEVALUESTRING,
  _swigc__p_FIX__MailingDtls,
  _swigc__p_FIX__MailingInst,
  _swigc__p_FIX__ManualOrderIndicator,
  _swigc__p_FIX__MarginExcess,
  _swigc__p_FIX__MarginRatio,
  _swigc__p_FIX__MarketDepth,
  _swigc__p_FIX__MarketID,
  _swigc__p_FIX__MarketReportID,
  _swigc__p_FIX__MarketReqID,
  _swigc__p_FIX__MarketSegmentDesc,
  _swigc__p_FIX__MarketSegmentID,
  _swigc__p_FIX__MarketUpdateAction,
  _swigc__p_FIX__MassActionRejectReason,
  _swigc__p_FIX__MassActionReportID,
  _swigc__p_FIX__MassActionResponse,
  _swigc__p_FIX__MassActionScope,
  _swigc__p_FIX__MassActionType,
  _swigc__p_FIX__MassCancelRejectReason,
  _swigc__p_FIX__MassCancelRequestType,
  _swigc__p_FIX__MassCancelResponse,
  _swigc__p_FIX__MassStatusReqID,
  _swigc__p_FIX__MassStatusReqType,
  _swigc__p_FIX__MatchAlgorithm,
  _swigc__p_FIX__MatchIncrement,
  _swigc__p_FIX__MatchStatus,
  _swigc__p_FIX__MatchType,
  _swigc__p_FIX__MaturityDate,
  _swigc__p_FIX__MaturityDay,
  _swigc__p_FIX__MaturityMonthYear,
  _swigc__p_FIX__MaturityMonthYearFormat,
  _swigc__p_FIX__MaturityMonthYearIncrement,
  _swigc__p_FIX__MaturityMonthYearIncrementUnits,
  _swigc__p_FIX__MaturityNetMoney,
  _swigc__p_FIX__MaturityRuleID,
  _swigc__p_FIX__MaturityTime,
  _swigc__p_FIX__MaxFloor,
  _swigc__p_FIX__MaxMessageSize,
  _swigc__p_FIX__MaxPriceLevels,
  _swigc__p_FIX__MaxPriceVariation,
  _swigc__p_FIX__MaxShow,
  _swigc__p_FIX__MaxTradeVol,
  _swigc__p_FIX__MemoryStore,
  _swigc__p_FIX__MemoryStoreFactory,
  _swigc__p_FIX__Message,
  _swigc__p_FIX__MessageEncoding,
  _swigc__p_FIX__MessageEventSource,
  _swigc__p_FIX__MessageParseError,
  _swigc__p_FIX__MessageStore,
  _swigc__p_FIX__MessageStoreExceptionWrapper,
  _swigc__p_FIX__MessageStoreFactory,
  _swigc__p_FIX__MessageStoreFactoryExceptionWrapper,
  _swigc__p_FIX__MidPx,
  _swigc__p_FIX__MidYield,
  _swigc__p_FIX__MinBidSize,
  _swigc__p_FIX__MinLotSize,
  _swigc__p_FIX__MinOfferSize,
  _swigc__p_FIX__MinPriceIncrement,
  _swigc__p_FIX__MinPriceIncrementAmount,
  _swigc__p_FIX__MinQty,
  _swigc__p_FIX__MinTradeVol,
  _swigc__p_FIX__MiscFeeAmt,
  _swigc__p_FIX__MiscFeeBasis,
  _swigc__p_FIX__MiscFeeCurr,
  _swigc__p_FIX__MiscFeeType,
  _swigc__p_FIX__MktBidPx,
  _swigc__p_FIX__MktOfferPx,
  _swigc__p_FIX__ModelType,
  _swigc__p_FIX__MoneyLaunderingStatus,
  _swigc__p_FIX__MsgDirection,
  _swigc__p_FIX__MsgSeqNum,
  _swigc__p_FIX__MsgType,
  _swigc__p_FIX__MultiLegReportingType,
  _swigc__p_FIX__MultiLegRptTypeReq,
  _swigc__p_FIX__MultilegModel,
  _swigc__p_FIX__MultilegPriceMethod,
  _swigc__p_FIX__NTPositionLimit,
  _swigc__p_FIX__NUMINGROUP,
  _swigc__p_FIX__Nested2PartyID,
  _swigc__p_FIX__Nested2PartyIDSource,
  _swigc__p_FIX__Nested2PartyRole,
  _swigc__p_FIX__Nested2PartySubID,
  _swigc__p_FIX__Nested2PartySubIDType,
  _swigc__p_FIX__Nested3PartyID,
  _swigc__p_FIX__Nested3PartyIDSource,
  _swigc__p_FIX__Nested3PartyRole,
  _swigc__p_FIX__Nested3PartySubID,
  _swigc__p_FIX__Nested3PartySubIDType,
  _swigc__p_FIX__Nested4PartyID,
  _swigc__p_FIX__Nested4PartyIDSource,
  _swigc__p_FIX__Nested4PartyRole,
  _swigc__p_FIX__Nested4PartySubID,
  _swigc__p_FIX__Nested4PartySubIDType,
  _swigc__p_FIX__NestedInstrAttribType,
  _swigc__p_FIX__NestedInstrAttribValue,
  _swigc__p_FIX__NestedPartyID,
  _swigc__p_FIX__NestedPartyIDSource,
  _swigc__p_FIX__NestedPartyRole,
  _swigc__p_FIX__NestedPartySubID,
  _swigc__p_FIX__NestedPartySubIDType,
  _swigc__p_FIX__NetChgPrevDay,
  _swigc__p_FIX__NetGrossInd,
  _swigc__p_FIX__NetMoney,
  _swigc__p_FIX__NetworkRequestID,
  _swigc__p_FIX__NetworkRequestType,
  _swigc__p_FIX__NetworkResponseID,
  _swigc__p_FIX__NetworkStatusResponseType,
  _swigc__p_FIX__NewPassword,
  _swigc__p_FIX__NewSeqNo,
  _swigc__p_FIX__NewsCategory,
  _swigc__p_FIX__NewsID,
  _swigc__p_FIX__NewsRefID,
  _swigc__p_FIX__NewsRefType,
  _swigc__p_FIX__NextExpectedMsgSeqNum,
  _swigc__p_FIX__NoAffectedOrders,
  _swigc__p_FIX__NoAllocs,
  _swigc__p_FIX__NoAltMDSource,
  _swigc__p_FIX__NoApplIDs,
  _swigc__p_FIX__NoAsgnReqs,
  _swigc__p_FIX__NoBidComponents,
  _swigc__p_FIX__NoBidDescriptors,
  _swigc__p_FIX__NoCapacities,
  _swigc__p_FIX__NoClearingInstructions,
  _swigc__p_FIX__NoCollInquiryQualifier,
  _swigc__p_FIX__NoCompIDs,
  _swigc__p_FIX__NoComplexEventDates,
  _swigc__p_FIX__NoComplexEventTimes,
  _swigc__p_FIX__NoComplexEvents,
  _swigc__p_FIX__NoContAmts,
  _swigc__p_FIX__NoContraBrokers,
  _swigc__p_FIX__NoDates,
  _swigc__p_FIX__NoDerivativeEvents,
  _swigc__p_FIX__NoDerivativeInstrAttrib,
  _swigc__p_FIX__NoDerivativeInstrumentParties,
  _swigc__p_FIX__NoDerivativeInstrumentPartySubIDs,
  _swigc__p_FIX__NoDerivativeSecurityAltID,
  _swigc__p_FIX__NoDistribInsts,
  _swigc__p_FIX__NoDlvyInst,
  _swigc__p_FIX__NoEvents,
  _swigc__p_FIX__NoExecInstRules,
  _swigc__p_FIX__NoExecs,
  _swigc__p_FIX__NoExpiration,
  _swigc__p_FIX__NoFills,
  _swigc__p_FIX__NoHops,
  _swigc__p_FIX__NoIOIQualifiers,
  _swigc__p_FIX__NoInstrAttrib,
  _swigc__p_FIX__NoInstrumentParties,
  _swigc__p_FIX__NoInstrumentPartySubIDs,
  _swigc__p_FIX__NoLegAllocs,
  _swigc__p_FIX__NoLegSecurityAltID,
  _swigc__p_FIX__NoLegStipulations,
  _swigc__p_FIX__NoLegs,
  _swigc__p_FIX__NoLinesOfText,
  _swigc__p_FIX__NoLotTypeRules,
  _swigc__p_FIX__NoMDEntries,
  _swigc__p_FIX__NoMDEntryTypes,
  _swigc__p_FIX__NoMDFeedTypes,
  _swigc__p_FIX__NoMarketSegments,
  _swigc__p_FIX__NoMatchRules,
  _swigc__p_FIX__NoMaturityRules,
  _swigc__p_FIX__NoMiscFees,
  _swigc__p_FIX__NoMsgTypes,
  _swigc__p_FIX__NoNested2PartyIDs,
  _swigc__p_FIX__NoNested2PartySubIDs,
  _swigc__p_FIX__NoNested3PartyIDs,
  _swigc__p_FIX__NoNested3PartySubIDs,
  _swigc__p_FIX__NoNested4PartyIDs,
  _swigc__p_FIX__NoNested4PartySubIDs,
  _swigc__p_FIX__NoNestedInstrAttrib,
  _swigc__p_FIX__NoNestedPartyIDs,
  _swigc__p_FIX__NoNestedPartySubIDs,
  _swigc__p_FIX__NoNewsRefIDs,
  _swigc__p_FIX__NoNotAffectedOrders,
  _swigc__p_FIX__NoOfLegUnderlyings,
  _swigc__p_FIX__NoOfSecSizes,
  _swigc__p_FIX__NoOrdTypeRules,
  _swigc__p_FIX__NoOrders,
  _swigc__p_FIX__NoPartyIDs,
  _swigc__p_FIX__NoPartySubIDs,
  _swigc__p_FIX__NoPosAmt,
  _swigc__p_FIX__NoPositions,
  _swigc__p_FIX__NoQuoteEntries,
  _swigc__p_FIX__NoQuoteQualifiers,
  _swigc__p_FIX__NoQuoteSets,
  _swigc__p_FIX__NoRateSources,
  _swigc__p_FIX__NoRegistDtls,
  _swigc__p_FIX__NoRelatedSym,
  _swigc__p_FIX__NoRootPartyIDs,
  _swigc__p_FIX__NoRootPartySubIDs,
  _swigc__p_FIX__NoRoutingIDs,
  _swigc__p_FIX__NoRpts,
  _swigc__p_FIX__NoSecurityAltID,
  _swigc__p_FIX__NoSecurityTypes,
  _swigc__p_FIX__NoSettlDetails,
  _swigc__p_FIX__NoSettlInst,
  _swigc__p_FIX__NoSettlOblig,
  _swigc__p_FIX__NoSettlPartyIDs,
  _swigc__p_FIX__NoSettlPartySubIDs,
  _swigc__p_FIX__NoSideTrdRegTS,
  _swigc__p_FIX__NoSides,
  _swigc__p_FIX__NoStatsIndicators,
  _swigc__p_FIX__NoStipulations,
  _swigc__p_FIX__NoStrategyParameters,
  _swigc__p_FIX__NoStrikeRules,
  _swigc__p_FIX__NoStrikes,
  _swigc__p_FIX__NoTagValue,
  _swigc__p_FIX__NoTargetPartyIDs,
  _swigc__p_FIX__NoTickRules,
  _swigc__p_FIX__NoTimeInForceRules,
  _swigc__p_FIX__NoTrades,
  _swigc__p_FIX__NoTradingSessionRules,
  _swigc__p_FIX__NoTradingSessions,
  _swigc__p_FIX__NoTrdRegTimestamps,
  _swigc__p_FIX__NoTrdRepIndicators,
  _swigc__p_FIX__NoUnderlyingAmounts,
  _swigc__p_FIX__NoUnderlyingLegSecurityAltID,
  _swigc__p_FIX__NoUnderlyingSecurityAltID,
  _swigc__p_FIX__NoUnderlyingStips,
  _swigc__p_FIX__NoUnderlyings,
  _swigc__p_FIX__NoUndlyInstrumentParties,
  _swigc__p_FIX__NoUndlyInstrumentPartySubIDs,
  _swigc__p_FIX__NotAffOrigClOrdID,
  _swigc__p_FIX__NotAffectedOrderID,
  _swigc__p_FIX__NotifyBrokerOfCredit,
  _swigc__p_FIX__NotionalPercentageOutstanding,
  _swigc__p_FIX__NullApplication,
  _swigc__p_FIX__NullLog,
  _swigc__p_FIX__NumBidders,
  _swigc__p_FIX__NumDaysInterest,
  _swigc__p_FIX__NumTickets,
  _swigc__p_FIX__NumberOfOrders,
  _swigc__p_FIX__OddLot,
  _swigc__p_FIX__OfferForwardPoints,
  _swigc__p_FIX__OfferForwardPoints2,
  _swigc__p_FIX__OfferPx,
  _swigc__p_FIX__OfferSize,
  _swigc__p_FIX__OfferSpotRate,
  _swigc__p_FIX__OfferSwapPoints,
  _swigc__p_FIX__OfferYield,
  _swigc__p_FIX__OnBehalfOfCompID,
  _swigc__p_FIX__OnBehalfOfLocationID,
  _swigc__p_FIX__OnBehalfOfSendingTime,
  _swigc__p_FIX__OnBehalfOfSubID,
  _swigc__p_FIX__OpenClose,
  _swigc__p_FIX__OpenCloseSettlFlag,
  _swigc__p_FIX__OpenCloseSettleFlag,
  _swigc__p_FIX__OpenInterest,
  _swigc__p_FIX__OptAttribute,
  _swigc__p_FIX__OptPayAmount,
  _swigc__p_FIX__OptPayoutAmount,
  _swigc__p_FIX__OptPayoutType,
  _swigc__p_FIX__OrdRejReason,
  _swigc__p_FIX__OrdStatus,
  _swigc__p_FIX__OrdStatusReqID,
  _swigc__p_FIX__OrdType,
  _swigc__p_FIX__OrderAvgPx,
  _swigc__p_FIX__OrderBookingQty,
  _swigc__p_FIX__OrderCapacity,
  _swigc__p_FIX__OrderCapacityQty,
  _swigc__p_FIX__OrderCategory,
  _swigc__p_FIX__OrderDelay,
  _swigc__p_FIX__OrderDelayUnit,
  _swigc__p_FIX__OrderHandlingInstSource,
  _swigc__p_FIX__OrderID,
  _swigc__p_FIX__OrderInputDevice,
  _swigc__p_FIX__OrderPercent,
  _swigc__p_FIX__OrderQty,
  _swigc__p_FIX__OrderQty2,
  _swigc__p_FIX__OrderRestrictions,
  _swigc__p_FIX__OrigClOrdID,
  _swigc__p_FIX__OrigCrossID,
  _swigc__p_FIX__OrigCustOrderCapacity,
  _swigc__p_FIX__OrigOrdModTime,
  _swigc__p_FIX__OrigPosReqRefID,
  _swigc__p_FIX__OrigSecondaryTradeID,
  _swigc__p_FIX__OrigSendingTime,
  _swigc__p_FIX__OrigTime,
  _swigc__p_FIX__OrigTradeDate,
  _swigc__p_FIX__OrigTradeHandlingInstr,
  _swigc__p_FIX__OrigTradeID,
  _swigc__p_FIX__OriginalNotionalPercentageOutstanding,
  _swigc__p_FIX__OutMainCntryUIndex,
  _swigc__p_FIX__OutsideIndexPct,
  _swigc__p_FIX__OwnerType,
  _swigc__p_FIX__OwnershipType,
  _swigc__p_FIX__PERCENTAGE,
  _swigc__p_FIX__PRICE,
  _swigc__p_FIX__PRICEOFFSET,
  _swigc__p_FIX__ParentMktSegmID,
  _swigc__p_FIX__ParticipationRate,
  _swigc__p_FIX__PartyID,
  _swigc__p_FIX__PartyIDSource,
  _swigc__p_FIX__PartyRole,
  _swigc__p_FIX__PartySubID,
  _swigc__p_FIX__PartySubIDType,
  _swigc__p_FIX__Password,
  _swigc__p_FIX__PaymentDate,
  _swigc__p_FIX__PaymentMethod,
  _swigc__p_FIX__PaymentRef,
  _swigc__p_FIX__PaymentRemitterID,
  _swigc__p_FIX__PctAtRisk,
  _swigc__p_FIX__PegDifference,
  _swigc__p_FIX__PegLimitType,
  _swigc__p_FIX__PegMoveType,
  _swigc__p_FIX__PegOffsetType,
  _swigc__p_FIX__PegOffsetValue,
  _swigc__p_FIX__PegPriceType,
  _swigc__p_FIX__PegRoundDirection,
  _swigc__p_FIX__PegScope,
  _swigc__p_FIX__PegSecurityDesc,
  _swigc__p_FIX__PegSecurityID,
  _swigc__p_FIX__PegSecurityIDSource,
  _swigc__p_FIX__PegSymbol,
  _swigc__p_FIX__PeggedPrice,
  _swigc__p_FIX__PeggedRefPrice,
  _swigc__p_FIX__Pool,
  _swigc__p_FIX__PosAmt,
  _swigc__p_FIX__PosAmtType,
  _swigc__p_FIX__PosMaintAction,
  _swigc__p_FIX__PosMaintResult,
  _swigc__p_FIX__PosMaintRptID,
  _swigc__p_FIX__PosMaintRptRefID,
  _swigc__p_FIX__PosMaintStatus,
  _swigc__p_FIX__PosQtyStatus,
  _swigc__p_FIX__PosReqID,
  _swigc__p_FIX__PosReqResult,
  _swigc__p_FIX__PosReqStatus,
  _swigc__p_FIX__PosReqType,
  _swigc__p_FIX__PosTransType,
  _swigc__p_FIX__PosType,
  _swigc__p_FIX__PositionCurrency,
  _swigc__p_FIX__PositionEffect,
  _swigc__p_FIX__PositionLimit,
  _swigc__p_FIX__PossDupFlag,
  _swigc__p_FIX__PossResend,
  _swigc__p_FIX__PreTradeAnonymity,
  _swigc__p_FIX__PreallocMethod,
  _swigc__p_FIX__PrevClosePx,
  _swigc__p_FIX__PreviouslyReported,
  _swigc__p_FIX__Price,
  _swigc__p_FIX__Price2,
  _swigc__p_FIX__PriceDelta,
  _swigc__p_FIX__PriceImprovement,
  _swigc__p_FIX__PriceLimitType,
  _swigc__p_FIX__PriceProtectionScope,
  _swigc__p_FIX__PriceQuoteMethod,
  _swigc__p_FIX__PriceType,
  _swigc__p_FIX__PriceUnitOfMeasure,
  _swigc__p_FIX__PriceUnitOfMeasureQty,
  _swigc__p_FIX__PriorSettlPrice,
  _swigc__p_FIX__PriorSpreadIndicator,
  _swigc__p_FIX__PriorityIndicator,
  _swigc__p_FIX__PrivateQuote,
  _swigc__p_FIX__ProcessCode,
  _swigc__p_FIX__Product,
  _swigc__p_FIX__ProductComplex,
  _swigc__p_FIX__ProgPeriodInterval,
  _swigc__p_FIX__ProgRptReqs,
  _swigc__p_FIX__PublishTrdIndicator,
  _swigc__p_FIX__PutOrCall,
  _swigc__p_FIX__QTY,
  _swigc__p_FIX__QtyType,
  _swigc__p_FIX__Quantity,
  _swigc__p_FIX__QuantityDate,
  _swigc__p_FIX__QuantityType,
  _swigc__p_FIX__QuoteAckStatus,
  _swigc__p_FIX__QuoteCancelType,
  _swigc__p_FIX__QuoteCondition,
  _swigc__p_FIX__QuoteEntryID,
  _swigc__p_FIX__QuoteEntryRejectReason,
  _swigc__p_FIX__QuoteEntryStatus,
  _swigc__p_FIX__QuoteID,
  _swigc__p_FIX__QuoteMsgID,
  _swigc__p_FIX__QuotePriceType,
  _swigc__p_FIX__QuoteQualifier,
  _swigc__p_FIX__QuoteRejectReason,
  _swigc__p_FIX__QuoteReqID,
  _swigc__p_FIX__QuoteRequestRejectReason,
  _swigc__p_FIX__QuoteRequestType,
  _swigc__p_FIX__QuoteRespID,
  _swigc__p_FIX__QuoteRespType,
  _swigc__p_FIX__QuoteResponseLevel,
  _swigc__p_FIX__QuoteSetID,
  _swigc__p_FIX__QuoteSetValidUntilTime,
  _swigc__p_FIX__QuoteStatus,
  _swigc__p_FIX__QuoteStatusReqID,
  _swigc__p_FIX__QuoteType,
  _swigc__p_FIX__RFQReqID,
  _swigc__p_FIX__RateSource,
  _swigc__p_FIX__RateSourceType,
  _swigc__p_FIX__RatioQty,
  _swigc__p_FIX__RawData,
  _swigc__p_FIX__RawDataLength,
  _swigc__p_FIX__ReceivedDeptID,
  _swigc__p_FIX__RedemptionDate,
  _swigc__p_FIX__RefAllocID,
  _swigc__p_FIX__RefApplExtID,
  _swigc__p_FIX__RefApplID,
  _swigc__p_FIX__RefApplLastSeqNum,
  _swigc__p_FIX__RefApplReqID,
  _swigc__p_FIX__RefApplVerID,
  _swigc__p_FIX__RefCompID,
  _swigc__p_FIX__RefCstmApplVerID,
  _swigc__p_FIX__RefMsgType,
  _swigc__p_FIX__RefOrdIDReason,
  _swigc__p_FIX__RefOrderID,
  _swigc__p_FIX__RefOrderIDSource,
  _swigc__p_FIX__RefSeqNum,
  _swigc__p_FIX__RefSubID,
  _swigc__p_FIX__RefTagID,
  _swigc__p_FIX__ReferencePage,
  _swigc__p_FIX__RefreshIndicator,
  _swigc__p_FIX__RefreshQty,
  _swigc__p_FIX__RegistAcctType,
  _swigc__p_FIX__RegistDetls,
  _swigc__p_FIX__RegistDtls,
  _swigc__p_FIX__RegistEmail,
  _swigc__p_FIX__RegistID,
  _swigc__p_FIX__RegistRefID,
  _swigc__p_FIX__RegistRejReasonCode,
  _swigc__p_FIX__RegistRejReasonText,
  _swigc__p_FIX__RegistStatus,
  _swigc__p_FIX__RegistTransType,
  _swigc__p_FIX__RejectLogon,
  _swigc__p_FIX__RejectText,
  _swigc__p_FIX__RelSymTransactTime,
  _swigc__p_FIX__RelatdSym,
  _swigc__p_FIX__RepeatedTag,
  _swigc__p_FIX__RepeatingGroupCountMismatch,
  _swigc__p_FIX__RepoCollateralSecurityType,
  _swigc__p_FIX__ReportToExch,
  _swigc__p_FIX__ReportedPx,
  _swigc__p_FIX__ReportedPxDiff,
  _swigc__p_FIX__RepurchaseRate,
  _swigc__p_FIX__RepurchaseTerm,
  _swigc__p_FIX__RequiredTagMissing,
  _swigc__p_FIX__ResetSeqNumFlag,
  _swigc__p_FIX__RespondentType,
  _swigc__p_FIX__ResponseDestination,
  _swigc__p_FIX__ResponseTransportType,
  _swigc__p_FIX__RestructuringType,
  _swigc__p_FIX__ReversalIndicator,
  _swigc__p_FIX__RiskFreeRate,
  _swigc__p_FIX__RndPx,
  _swigc__p_FIX__RootPartyID,
  _swigc__p_FIX__RootPartyIDSource,
  _swigc__p_FIX__RootPartyRole,
  _swigc__p_FIX__RootPartySubID,
  _swigc__p_FIX__RootPartySubIDType,
  _swigc__p_FIX__RoundLot,
  _swigc__p_FIX__RoundingDirection,
  _swigc__p_FIX__RoundingModulus,
  _swigc__p_FIX__RoutingID,
  _swigc__p_FIX__RoutingType,
  _swigc__p_FIX__RptSeq,
  _swigc__p_FIX__RptSys,
  _swigc__p_FIX__Rule80A,
  _swigc__p_FIX__RuntimeError,
  _swigc__p_FIX__SEQNUM,
  _swigc__p_FIX__STRING,
  _swigc__p_FIX__Scope,
  _swigc__p_FIX__ScreenLog,
  _swigc__p_FIX__ScreenLogFactory,
  _swigc__p_FIX__SecondaryAllocID,
  _swigc__p_FIX__SecondaryClOrdID,
  _swigc__p_FIX__SecondaryDisplayQty,
  _swigc__p_FIX__SecondaryExecID,
  _swigc__p_FIX__SecondaryFirmTradeID,
  _swigc__p_FIX__SecondaryHighLimitPrice,
  _swigc__p_FIX__SecondaryIndividualAllocID,
  _swigc__p_FIX__SecondaryLowLimitPrice,
  _swigc__p_FIX__SecondaryOrderID,
  _swigc__p_FIX__SecondaryPriceLimitType,
  _swigc__p_FIX__SecondaryTradeID,
  _swigc__p_FIX__SecondaryTradeReportID,
  _swigc__p_FIX__SecondaryTradeReportRefID,
  _swigc__p_FIX__SecondaryTradingReferencePrice,
  _swigc__p_FIX__SecondaryTrdType,
  _swigc__p_FIX__SecureData,
  _swigc__p_FIX__SecureDataLen,
  _swigc__p_FIX__SecurityAltID,
  _swigc__p_FIX__SecurityAltIDSource,
  _swigc__p_FIX__SecurityDesc,
  _swigc__p_FIX__SecurityExchange,
  _swigc__p_FIX__SecurityGroup,
  _swigc__p_FIX__SecurityID,
  _swigc__p_FIX__SecurityIDSource,
  _swigc__p_FIX__SecurityListDesc,
  _swigc__p_FIX__SecurityListID,
  _swigc__p_FIX__SecurityListRefID,
  _swigc__p_FIX__SecurityListRequestType,
  _swigc__p_FIX__SecurityListType,
  _swigc__p_FIX__SecurityListTypeSource,
  _swigc__p_FIX__SecurityReportID,
  _swigc__p_FIX__SecurityReqID,
  _swigc__p_FIX__SecurityRequestResult,
  _swigc__p_FIX__SecurityRequestType,
  _swigc__p_FIX__SecurityResponseID,
  _swigc__p_FIX__SecurityResponseType,
  _swigc__p_FIX__SecuritySettlAgentAcctName,
  _swigc__p_FIX__SecuritySettlAgentAcctNum,
  _swigc__p_FIX__SecuritySettlAgentCode,
  _swigc__p_FIX__SecuritySettlAgentContactName,
  _swigc__p_FIX__SecuritySettlAgentContactPhone,
  _swigc__p_FIX__SecuritySettlAgentName,
  _swigc__p_FIX__SecurityStatus,
  _swigc__p_FIX__SecurityStatusReqID,
  _swigc__p_FIX__SecuritySubType,
  _swigc__p_FIX__SecurityTradingEvent,
  _swigc__p_FIX__SecurityTradingStatus,
  _swigc__p_FIX__SecurityType,
  _swigc__p_FIX__SecurityUpdateAction,
  _swigc__p_FIX__SecurityXML,
  _swigc__p_FIX__SecurityXMLLen,
  _swigc__p_FIX__SecurityXMLSchema,
  _swigc__p_FIX__SellVolume,
  _swigc__p_FIX__SellerDays,
  _swigc__p_FIX__SenderCompID,
  _swigc__p_FIX__SenderLocationID,
  _swigc__p_FIX__SenderSubID,
  _swigc__p_FIX__SendingDate,
  _swigc__p_FIX__SendingTime,
  _swigc__p_FIX__Seniority,
  _swigc__p_FIX__Session,
  _swigc__p_FIX__SessionID,
  _swigc__p_FIX__SessionNotFound,
  _swigc__p_FIX__SessionRejectReason,
  _swigc__p_FIX__SessionSettings,
  _swigc__p_FIX__SessionStatus,
  _swigc__p_FIX__SettlBrkrCode,
  _swigc__p_FIX__SettlCurrAmt,
  _swigc__p_FIX__SettlCurrBidFxRate,
  _swigc__p_FIX__SettlCurrFxRate,
  _swigc__p_FIX__SettlCurrFxRateCalc,
  _swigc__p_FIX__SettlCurrOfferFxRate,
  _swigc__p_FIX__SettlCurrency,
  _swigc__p_FIX__SettlDate,
  _swigc__p_FIX__SettlDate2,
  _swigc__p_FIX__SettlDeliveryType,
  _swigc__p_FIX__SettlDepositoryCode,
  _swigc__p_FIX__SettlInstCode,
  _swigc__p_FIX__SettlInstID,
  _swigc__p_FIX__SettlInstMode,
  _swigc__p_FIX__SettlInstMsgID,
  _swigc__p_FIX__SettlInstRefID,
  _swigc__p_FIX__SettlInstReqID,
  _swigc__p_FIX__SettlInstReqRejCode,
  _swigc__p_FIX__SettlInstSource,
  _swigc__p_FIX__SettlInstTransType,
  _swigc__p_FIX__SettlLocation,
  _swigc__p_FIX__SettlMethod,
  _swigc__p_FIX__SettlObligID,
  _swigc__p_FIX__SettlObligMode,
  _swigc__p_FIX__SettlObligMsgID,
  _swigc__p_FIX__SettlObligRefID,
  _swigc__p_FIX__SettlObligSource,
  _swigc__p_FIX__SettlObligTransType,
  _swigc__p_FIX__SettlPartyID,
  _swigc__p_FIX__SettlPartyIDSource,
  _swigc__p_FIX__SettlPartyRole,
  _swigc__p_FIX__SettlPartySubID,
  _swigc__p_FIX__SettlPartySubIDType,
  _swigc__p_FIX__SettlPrice,
  _swigc__p_FIX__SettlPriceType,
  _swigc__p_FIX__SettlSessID,
  _swigc__p_FIX__SettlSessSubID,
  _swigc__p_FIX__SettlType,
  _swigc__p_FIX__SettleOnOpenFlag,
  _swigc__p_FIX__SettlementCycleNo,
  _swigc__p_FIX__SettlmntTyp,
  _swigc__p_FIX__SharedCommission,
  _swigc__p_FIX__Shares,
  _swigc__p_FIX__ShortQty,
  _swigc__p_FIX__ShortSaleReason,
  _swigc__p_FIX__Side,
  _swigc__p_FIX__SideComplianceID,
  _swigc__p_FIX__SideCurrency,
  _swigc__p_FIX__SideExecID,
  _swigc__p_FIX__SideFillStationCd,
  _swigc__p_FIX__SideGrossTradeAmt,
  _swigc__p_FIX__SideLastQty,
  _swigc__p_FIX__SideLiquidityInd,
  _swigc__p_FIX__SideMultiLegReportingType,
  _swigc__p_FIX__SideQty,
  _swigc__p_FIX__SideReasonCd,
  _swigc__p_FIX__SideSettlCurrency,
  _swigc__p_FIX__SideTimeInForce,
  _swigc__p_FIX__SideTradeReportID,
  _swigc__p_FIX__SideTrdRegTimestamp,
  _swigc__p_FIX__SideTrdRegTimestampSrc,
  _swigc__p_FIX__SideTrdRegTimestampType,
  _swigc__p_FIX__SideTrdSubTyp,
  _swigc__p_FIX__SideValue1,
  _swigc__p_FIX__SideValue2,
  _swigc__p_FIX__SideValueInd,
  _swigc__p_FIX__Signature,
  _swigc__p_FIX__SignatureLength,
  _swigc__p_FIX__SocketAcceptor,
  _swigc__p_FIX__SocketCloseFailed,
  _swigc__p_FIX__SocketException,
  _swigc__p_FIX__SocketInitiator,
  _swigc__p_FIX__SocketRecvFailed,
  _swigc__p_FIX__SocketSendFailed,
  _swigc__p_FIX__SolicitedFlag,
  _swigc__p_FIX__Spread,
  _swigc__p_FIX__SpreadToBenchmark,
  _swigc__p_FIX__StandInstDbID,
  _swigc__p_FIX__StandInstDbName,
  _swigc__p_FIX__StandInstDbType,
  _swigc__p_FIX__StartCash,
  _swigc__p_FIX__StartDate,
  _swigc__p_FIX__StartMaturityMonthYear,
  _swigc__p_FIX__StartStrikePxRange,
  _swigc__p_FIX__StartTickPriceRange,
  _swigc__p_FIX__StateOrProvinceOfIssue,
  _swigc__p_FIX__StatsType,
  _swigc__p_FIX__StatusText,
  _swigc__p_FIX__StatusValue,
  _swigc__p_FIX__StipulationType,
  _swigc__p_FIX__StipulationValue,
  _swigc__p_FIX__StopPx,
  _swigc__p_FIX__StrategyParameterName,
  _swigc__p_FIX__StrategyParameterType,
  _swigc__p_FIX__StrategyParameterValue,
  _swigc__p_FIX__StreamAsgnAckType,
  _swigc__p_FIX__StreamAsgnRejReason,
  _swigc__p_FIX__StreamAsgnReqID,
  _swigc__p_FIX__StreamAsgnReqType,
  _swigc__p_FIX__StreamAsgnRptID,
  _swigc__p_FIX__StreamAsgnType,
  _swigc__p_FIX__StrikeCurrency,
  _swigc__p_FIX__StrikeExerciseStyle,
  _swigc__p_FIX__StrikeIncrement,
  _swigc__p_FIX__StrikeMultiplier,
  _swigc__p_FIX__StrikePrice,
  _swigc__p_FIX__StrikePriceBoundaryMethod,
  _swigc__p_FIX__StrikePriceBoundaryPrecision,
  _swigc__p_FIX__StrikePriceDeterminationMethod,
  _swigc__p_FIX__StrikeRuleID,
  _swigc__p_FIX__StrikeTime,
  _swigc__p_FIX__StrikeValue,
  _swigc__p_FIX__StringField,
  _swigc__p_FIX__Subject,
  _swigc__p_FIX__SubscriptionRequestType,
  _swigc__p_FIX__SwapPoints,
  _swigc__p_FIX__Symbol,
  _swigc__p_FIX__SymbolSfx,
  _swigc__p_FIX__SynchronizedApplication,
  _swigc__p_FIX__TYPE__Type,
  _swigc__p_FIX__TZTIMEONLY,
  _swigc__p_FIX__TZTIMESTAMP,
  _swigc__p_FIX__TZTransactTime,
  _swigc__p_FIX__TagNotDefinedForMessage,
  _swigc__p_FIX__TagOutOfOrder,
  _swigc__p_FIX__TargetCompID,
  _swigc__p_FIX__TargetLocationID,
  _swigc__p_FIX__TargetPartyID,
  _swigc__p_FIX__TargetPartyIDSource,
  _swigc__p_FIX__TargetPartyRole,
  _swigc__p_FIX__TargetStrategy,
  _swigc__p_FIX__TargetStrategyParameters,
  _swigc__p_FIX__TargetStrategyPerformance,
  _swigc__p_FIX__TargetSubID,
  _swigc__p_FIX__TaxAdvantageType,
  _swigc__p_FIX__TerminationType,
  _swigc__p_FIX__TestMessageIndicator,
  _swigc__p_FIX__TestReqID,
  _swigc__p_FIX__Text,
  _swigc__p_FIX__ThresholdAmount,
  _swigc__p_FIX__TickDirection,
  _swigc__p_FIX__TickIncrement,
  _swigc__p_FIX__TickRuleType,
  _swigc__p_FIX__TierCode,
  _swigc__p_FIX__TimeBracket,
  _swigc__p_FIX__TimeInForce,
  _swigc__p_FIX__TimeToExpiration,
  _swigc__p_FIX__TimeUnit,
  _swigc__p_FIX__TotNoAccQuotes,
  _swigc__p_FIX__TotNoAllocs,
  _swigc__p_FIX__TotNoCxldQuotes,
  _swigc__p_FIX__TotNoFills,
  _swigc__p_FIX__TotNoOrders,
  _swigc__p_FIX__TotNoQuoteEntries,
  _swigc__p_FIX__TotNoRejQuotes,
  _swigc__p_FIX__TotNoRelatedSym,
  _swigc__p_FIX__TotNoSecurityTypes,
  _swigc__p_FIX__TotNoStrikes,
  _swigc__p_FIX__TotNumAssignmentReports,
  _swigc__p_FIX__TotNumReports,
  _swigc__p_FIX__TotNumTradeReports,
  _swigc__p_FIX__TotQuoteEntries,
  _swigc__p_FIX__TotalAccruedInterestAmt,
  _swigc__p_FIX__TotalAffectedOrders,
  _swigc__p_FIX__TotalNetValue,
  _swigc__p_FIX__TotalNumPosReports,
  _swigc__p_FIX__TotalNumSecurities,
  _swigc__p_FIX__TotalNumSecurityTypes,
  _swigc__p_FIX__TotalTakedown,
  _swigc__p_FIX__TotalVolumeTraded,
  _swigc__p_FIX__TotalVolumeTradedDate,
  _swigc__p_FIX__TotalVolumeTradedTime,
  _swigc__p_FIX__TradSesCloseTime,
  _swigc__p_FIX__TradSesEndTime,
  _swigc__p_FIX__TradSesEvent,
  _swigc__p_FIX__TradSesMethod,
  _swigc__p_FIX__TradSesMode,
  _swigc__p_FIX__TradSesOpenTime,
  _swigc__p_FIX__TradSesPreCloseTime,
  _swigc__p_FIX__TradSesReqID,
  _swigc__p_FIX__TradSesStartTime,
  _swigc__p_FIX__TradSesStatus,
  _swigc__p_FIX__TradSesStatusRejReason,
  _swigc__p_FIX__TradSesUpdateAction,
  _swigc__p_FIX__TradeAllocIndicator,
  _swigc__p_FIX__TradeCondition,
  _swigc__p_FIX__TradeDate,
  _swigc__p_FIX__TradeHandlingInstr,
  _swigc__p_FIX__TradeID,
  _swigc__p_FIX__TradeInputDevice,
  _swigc__p_FIX__TradeInputSource,
  _swigc__p_FIX__TradeLegRefID,
  _swigc__p_FIX__TradeLinkID,
  _swigc__p_FIX__TradeOriginationDate,
  _swigc__p_FIX__TradePublishIndicator,
  _swigc__p_FIX__TradeReportID,
  _swigc__p_FIX__TradeReportRefID,
  _swigc__p_FIX__TradeReportRejectReason,
  _swigc__p_FIX__TradeReportTransType,
  _swigc__p_FIX__TradeReportType,
  _swigc__p_FIX__TradeRequestID,
  _swigc__p_FIX__TradeRequestResult,
  _swigc__p_FIX__TradeRequestStatus,
  _swigc__p_FIX__TradeRequestType,
  _swigc__p_FIX__TradeType,
  _swigc__p_FIX__TradeVolume,
  _swigc__p_FIX__TradedFlatSwitch,
  _swigc__p_FIX__TradingCurrency,
  _swigc__p_FIX__TradingReferencePrice,
  _swigc__p_FIX__TradingSessionDesc,
  _swigc__p_FIX__TradingSessionID,
  _swigc__p_FIX__TradingSessionSubID,
  _swigc__p_FIX__Trailer,
  _swigc__p_FIX__TransBkdTime,
  _swigc__p_FIX__TransactTime,
  _swigc__p_FIX__TransferReason,
  _swigc__p_FIX__TrdMatchID,
  _swigc__p_FIX__TrdRegTimestamp,
  _swigc__p_FIX__TrdRegTimestampOrigin,
  _swigc__p_FIX__TrdRegTimestampType,
  _swigc__p_FIX__TrdRepIndicator,
  _swigc__p_FIX__TrdRepPartyRole,
  _swigc__p_FIX__TrdRptStatus,
  _swigc__p_FIX__TrdSubType,
  _swigc__p_FIX__TrdType,
  _swigc__p_FIX__TriggerAction,
  _swigc__p_FIX__TriggerNewPrice,
  _swigc__p_FIX__TriggerNewQty,
  _swigc__p_FIX__TriggerOrderType,
  _swigc__p_FIX__TriggerPrice,
  _swigc__p_FIX__TriggerPriceDirection,
  _swigc__p_FIX__TriggerPriceType,
  _swigc__p_FIX__TriggerPriceTypeScope,
  _swigc__p_FIX__TriggerSecurityDesc,
  _swigc__p_FIX__TriggerSecurityID,
  _swigc__p_FIX__TriggerSecurityIDSource,
  _swigc__p_FIX__TriggerSymbol,
  _swigc__p_FIX__TriggerTradingSessionID,
  _swigc__p_FIX__TriggerTradingSessionSubID,
  _swigc__p_FIX__TriggerType,
  _swigc__p_FIX__URLLink,
  _swigc__p_FIX__UTCDATE,
  _swigc__p_FIX__UTCDATEONLY,
  _swigc__p_FIX__UTCTIMEONLY,
  _swigc__p_FIX__UTCTIMESTAMP,
  _swigc__p_FIX__UnderlyingAdjustedQuantity,
  _swigc__p_FIX__UnderlyingAllocationPercent,
  _swigc__p_FIX__UnderlyingAttachmentPoint,
  _swigc__p_FIX__UnderlyingCFICode,
  _swigc__p_FIX__UnderlyingCPProgram,
  _swigc__p_FIX__UnderlyingCPRegType,
  _swigc__p_FIX__UnderlyingCapValue,
  _swigc__p_FIX__UnderlyingCashAmount,
  _swigc__p_FIX__UnderlyingCashType,
  _swigc__p_FIX__UnderlyingCollectAmount,
  _swigc__p_FIX__UnderlyingContractMultiplier,
  _swigc__p_FIX__UnderlyingContractMultiplierUnit,
  _swigc__p_FIX__UnderlyingCountryOfIssue,
  _swigc__p_FIX__UnderlyingCouponPaymentDate,
  _swigc__p_FIX__UnderlyingCouponRate,
  _swigc__p_FIX__UnderlyingCreditRating,
  _swigc__p_FIX__UnderlyingCurrency,
  _swigc__p_FIX__UnderlyingCurrentValue,
  _swigc__p_FIX__UnderlyingDeliveryAmount,
  _swigc__p_FIX__UnderlyingDetachmentPoint,
  _swigc__p_FIX__UnderlyingDirtyPrice,
  _swigc__p_FIX__UnderlyingEndPrice,
  _swigc__p_FIX__UnderlyingEndValue,
  _swigc__p_FIX__UnderlyingExerciseStyle,
  _swigc__p_FIX__UnderlyingFXRate,
  _swigc__p_FIX__UnderlyingFXRateCalc,
  _swigc__p_FIX__UnderlyingFactor,
  _swigc__p_FIX__UnderlyingFlowScheduleType,
  _swigc__p_FIX__UnderlyingIDSource,
  _swigc__p_FIX__UnderlyingInstrRegistry,
  _swigc__p_FIX__UnderlyingInstrumentPartyID,
  _swigc__p_FIX__UnderlyingInstrumentPartyIDSource,
  _swigc__p_FIX__UnderlyingInstrumentPartyRole,
  _swigc__p_FIX__UnderlyingInstrumentPartySubID,
  _swigc__p_FIX__UnderlyingInstrumentPartySubIDType,
  _swigc__p_FIX__UnderlyingIssueDate,
  _swigc__p_FIX__UnderlyingIssuer,
  _swigc__p_FIX__UnderlyingLastPx,
  _swigc__p_FIX__UnderlyingLastQty,
  _swigc__p_FIX__UnderlyingLegCFICode,
  _swigc__p_FIX__UnderlyingLegMaturityDate,
  _swigc__p_FIX__UnderlyingLegMaturityMonthYear,
  _swigc__p_FIX__UnderlyingLegMaturityTime,
  _swigc__p_FIX__UnderlyingLegOptAttribute,
  _swigc__p_FIX__UnderlyingLegPutOrCall,
  _swigc__p_FIX__UnderlyingLegSecurityAltID,
  _swigc__p_FIX__UnderlyingLegSecurityAltIDSource,
  _swigc__p_FIX__UnderlyingLegSecurityDesc,
  _swigc__p_FIX__UnderlyingLegSecurityExchange,
  _swigc__p_FIX__UnderlyingLegSecurityID,
  _swigc__p_FIX__UnderlyingLegSecurityIDSource,
  _swigc__p_FIX__UnderlyingLegSecuritySubType,
  _swigc__p_FIX__UnderlyingLegSecurityType,
  _swigc__p_FIX__UnderlyingLegStrikePrice,
  _swigc__p_FIX__UnderlyingLegSymbol,
  _swigc__p_FIX__UnderlyingLegSymbolSfx,
  _swigc__p_FIX__UnderlyingLocaleOfIssue,
  _swigc__p_FIX__UnderlyingMaturityDate,
  _swigc__p_FIX__UnderlyingMaturityDay,
  _swigc__p_FIX__UnderlyingMaturityMonthYear,
  _swigc__p_FIX__UnderlyingMaturityTime,
  _swigc__p_FIX__UnderlyingNotionalPercentageOutstanding,
  _swigc__p_FIX__UnderlyingOptAttribute,
  _swigc__p_FIX__UnderlyingOriginalNotionalPercentageOutstanding,
  _swigc__p_FIX__UnderlyingPayAmount,
  _swigc__p_FIX__UnderlyingPriceDeterminationMethod,
  _swigc__p_FIX__UnderlyingPriceUnitOfMeasure,
  _swigc__p_FIX__UnderlyingPriceUnitOfMeasureQty,
  _swigc__p_FIX__UnderlyingProduct,
  _swigc__p_FIX__UnderlyingPutOrCall,
  _swigc__p_FIX__UnderlyingPx,
  _swigc__p_FIX__UnderlyingQty,
  _swigc__p_FIX__UnderlyingRedemptionDate,
  _swigc__p_FIX__UnderlyingRepoCollateralSecurityType,
  _swigc__p_FIX__UnderlyingRepurchaseRate,
  _swigc__p_FIX__UnderlyingRepurchaseTerm,
  _swigc__p_FIX__UnderlyingRestructuringType,
  _swigc__p_FIX__UnderlyingSecurityAltID,
  _swigc__p_FIX__UnderlyingSecurityAltIDSource,
  _swigc__p_FIX__UnderlyingSecurityDesc,
  _swigc__p_FIX__UnderlyingSecurityExchange,
  _swigc__p_FIX__UnderlyingSecurityID,
  _swigc__p_FIX__UnderlyingSecurityIDSource,
  _swigc__p_FIX__UnderlyingSecuritySubType,
  _swigc__p_FIX__UnderlyingSecurityType,
  _swigc__p_FIX__UnderlyingSeniority,
  _swigc__p_FIX__UnderlyingSettlMethod,
  _swigc__p_FIX__UnderlyingSettlPrice,
  _swigc__p_FIX__UnderlyingSettlPriceType,
  _swigc__p_FIX__UnderlyingSettlementDate,
  _swigc__p_FIX__UnderlyingSettlementStatus,
  _swigc__p_FIX__UnderlyingSettlementType,
  _swigc__p_FIX__UnderlyingStartValue,
  _swigc__p_FIX__UnderlyingStateOrProvinceOfIssue,
  _swigc__p_FIX__UnderlyingStipType,
  _swigc__p_FIX__UnderlyingStipValue,
  _swigc__p_FIX__UnderlyingStrikeCurrency,
  _swigc__p_FIX__UnderlyingStrikePrice,
  _swigc__p_FIX__UnderlyingSymbol,
  _swigc__p_FIX__UnderlyingSymbolSfx,
  _swigc__p_FIX__UnderlyingTimeUnit,
  _swigc__p_FIX__UnderlyingTradingSessionID,
  _swigc__p_FIX__UnderlyingTradingSessionSubID,
  _swigc__p_FIX__UnderlyingUnitOfMeasure,
  _swigc__p_FIX__UnderlyingUnitOfMeasureQty,
  _swigc__p_FIX__UndlyInstrumentPartyID,
  _swigc__p_FIX__UndlyInstrumentPartyIDSource,
  _swigc__p_FIX__UndlyInstrumentPartyRole,
  _swigc__p_FIX__UndlyInstrumentPartySubID,
  _swigc__p_FIX__UndlyInstrumentPartySubIDType,
  _swigc__p_FIX__UnitOfMeasure,
  _swigc__p_FIX__UnitOfMeasureQty,
  _swigc__p_FIX__UnsolicitedIndicator,
  _swigc__p_FIX__UnsupportedMessageType,
  _swigc__p_FIX__UnsupportedVersion,
  _swigc__p_FIX__Urgency,
  _swigc__p_FIX__UserRequestID,
  _swigc__p_FIX__UserRequestType,
  _swigc__p_FIX__UserStatus,
  _swigc__p_FIX__UserStatusText,
  _swigc__p_FIX__Username,
  _swigc__p_FIX__UtcDateField,
  _swigc__p_FIX__UtcTimeOnlyField,
  _swigc__p_FIX__UtcTimeStampField,
  _swigc__p_FIX__ValidUntilTime,
  _swigc__p_FIX__ValuationMethod,
  _swigc__p_FIX__ValueOfFutures,
  _swigc__p_FIX__VenueType,
  _swigc__p_FIX__Volatility,
  _swigc__p_FIX__WaveNo,
  _swigc__p_FIX__WorkingIndicator,
  _swigc__p_FIX__WtAverageLiquidity,
  _swigc__p_FIX__XMLDATA,
  _swigc__p_FIX__XmlData,
  _swigc__p_FIX__XmlDataLen,
  _swigc__p_FIX__Yield,
  _swigc__p_FIX__YieldCalcDate,
  _swigc__p_FIX__YieldRedemptionDate,
  _swigc__p_FIX__YieldRedemptionPrice,
  _swigc__p_FIX__YieldRedemptionPriceType,
  _swigc__p_FIX__YieldType,
  _swigc__p_Fields,
  _swigc__p_Group,
  _swigc__p_Groups,
  _swigc__p_IntArray,
  _swigc__p_IntField,
  _swigc__p_Log,
  _swigc__p_LogFactory,
  _swigc__p_MessageStore,
  _swigc__p_MessageStoreFactory,
  _swigc__p_MsgType,
  _swigc__p_Mutex,
  _swigc__p_Responder,
  _swigc__p_SessionID,
  _swigc__p_StringField,
  _swigc__p_TimeRange,
  _swigc__p_UtcDate,
  _swigc__p_UtcDateField,
  _swigc__p_UtcTimeOnly,
  _swigc__p_UtcTimeStamp,
  _swigc__p_bool,
  _swigc__p_char,
  _swigc__p_const_iterator,
  _swigc__p_g_const_iterator,
  _swigc__p_g_iterator,
  _swigc__p_int,
  _swigc__p_iterator,
  _swigc__p_message_order,
  _swigc__p_p_FIX__DataDictionary,
  _swigc__p_std__istream,
  _swigc__p_std__ostream,
  _swigc__p_std__setT_FIX__SessionID_t,
  _swigc__p_std__string,
  _swigc__p_std__string__size_type,
  _swigc__p_std__vectorT_std__string_t,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is 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 staticly 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 found, init;
  
  clientdata = clientdata;
  
  /* 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);
    module_head = &swig_module;
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    found=0;
    iter=module_head;
    do {
      if (iter==&swig_module) {
        found=1;
        break;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* if the is found in the list, then all is done and we may leave */
    if (found) return;
    /* otherwise we must add out module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpeters 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_SetString(PyExc_NameError,"Unknown C global variable");
    }
    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_SetString(PyExc_NameError,"Unknown C global variable");
    }
    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 */
#endif
#ifdef COUNT_ALLOCS
        0,0,0,0                             /* tp_alloc -> 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 && (c = strstr(c, "swig_ptr: "))) {
        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;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  
  /* 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);
  
  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*)"headerOrder",Swig_var_headerOrder_get, Swig_var_headerOrder_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BeginString_FIXT11",Swig_var_BeginString_FIXT11_get, Swig_var_BeginString_FIXT11_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BeginString_FIX50",Swig_var_BeginString_FIX50_get, Swig_var_BeginString_FIX50_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BeginString_FIX44",Swig_var_BeginString_FIX44_get, Swig_var_BeginString_FIX44_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BeginString_FIX43",Swig_var_BeginString_FIX43_get, Swig_var_BeginString_FIX43_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BeginString_FIX42",Swig_var_BeginString_FIX42_get, Swig_var_BeginString_FIX42_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BeginString_FIX41",Swig_var_BeginString_FIX41_get, Swig_var_BeginString_FIX41_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BeginString_FIX40",Swig_var_BeginString_FIX40_get, Swig_var_BeginString_FIX40_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INVALID_TAG_NUMBER_TEXT",Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_TEXT_get, Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_REQUIRED_TAG_MISSING_TEXT",Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_TEXT_get, Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT",Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT_get, Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_UNDEFINED_TAG_TEXT",Swig_var_SessionRejectReason_UNDEFINED_TAG_TEXT_get, Swig_var_SessionRejectReason_UNDEFINED_TAG_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT",Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT_get, Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_VALUE_IS_INCORRECT_TEXT",Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_TEXT_get, Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT",Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT_get, Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_DECRYPTION_PROBLEM_TEXT",Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_TEXT_get, Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_SIGNATURE_PROBLEM_TEXT",Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_TEXT_get, Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_COMPID_PROBLEM_TEXT",Swig_var_SessionRejectReason_COMPID_PROBLEM_TEXT_get, Swig_var_SessionRejectReason_COMPID_PROBLEM_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT",Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT_get, Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INVALID_MSGTYPE_TEXT",Swig_var_SessionRejectReason_INVALID_MSGTYPE_TEXT_get, Swig_var_SessionRejectReason_INVALID_MSGTYPE_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT",Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT_get, Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT",Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT_get, Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT",Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT_get, Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_OTHER_TEXT",Swig_var_BusinessRejectReason_OTHER_TEXT_get, Swig_var_BusinessRejectReason_OTHER_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKNOWN_ID_TEXT",Swig_var_BusinessRejectReason_UNKNOWN_ID_TEXT_get, Swig_var_BusinessRejectReason_UNKNOWN_ID_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKNOWN_SECURITY_TEXT",Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_TEXT_get, Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT",Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT_get, Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT",Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT_get, Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT",Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT_get, Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_NOT_AUTHORIZED_TEXT",Swig_var_BusinessRejectReason_NOT_AUTHORIZED_TEXT_get, Swig_var_BusinessRejectReason_NOT_AUTHORIZED_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT",Swig_var_BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT_get, Swig_var_BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryForm_BOOKENTRY",Swig_var_DeliveryForm_BOOKENTRY_get, Swig_var_DeliveryForm_BOOKENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryForm_BEARER",Swig_var_DeliveryForm_BEARER_get, Swig_var_DeliveryForm_BEARER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryForm_BOOK_ENTRY",Swig_var_DeliveryForm_BOOK_ENTRY_get, Swig_var_DeliveryForm_BOOK_ENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_WAREHOUSE_RECAP",Swig_var_ExecRestatementReason_WAREHOUSE_RECAP_get, Swig_var_ExecRestatementReason_WAREHOUSE_RECAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE",Swig_var_ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE_get, Swig_var_ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY",Swig_var_ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY_get, Swig_var_ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_GT_CORPORATE_ACTION",Swig_var_ExecRestatementReason_GT_CORPORATE_ACTION_get, Swig_var_ExecRestatementReason_GT_CORPORATE_ACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_PEG_REFRESH",Swig_var_ExecRestatementReason_PEG_REFRESH_get, Swig_var_ExecRestatementReason_PEG_REFRESH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_CANCELED_NOT_BEST",Swig_var_ExecRestatementReason_CANCELED_NOT_BEST_get, Swig_var_ExecRestatementReason_CANCELED_NOT_BEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_CANCEL_ON_TRADING_HALT",Swig_var_ExecRestatementReason_CANCEL_ON_TRADING_HALT_get, Swig_var_ExecRestatementReason_CANCEL_ON_TRADING_HALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_VERBAL_CHANGE",Swig_var_ExecRestatementReason_VERBAL_CHANGE_get, Swig_var_ExecRestatementReason_VERBAL_CHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_OTHER",Swig_var_ExecRestatementReason_OTHER_get, Swig_var_ExecRestatementReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_BROKER_OPTION",Swig_var_ExecRestatementReason_BROKER_OPTION_get, Swig_var_ExecRestatementReason_BROKER_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_REPRICING_OF_ORDER",Swig_var_ExecRestatementReason_REPRICING_OF_ORDER_get, Swig_var_ExecRestatementReason_REPRICING_OF_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_MARKET",Swig_var_ExecRestatementReason_MARKET_get, Swig_var_ExecRestatementReason_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecRestatementReason_GT_RENEWAL",Swig_var_ExecRestatementReason_GT_RENEWAL_get, Swig_var_ExecRestatementReason_GT_RENEWAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_PENDING_RELEASE",Swig_var_AllocIntermedReqType_PENDING_RELEASE_get, Swig_var_AllocIntermedReqType_PENDING_RELEASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_PENDING_REVERSAL",Swig_var_AllocIntermedReqType_PENDING_REVERSAL_get, Swig_var_AllocIntermedReqType_PENDING_REVERSAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_ACCOUNT_LEVEL_REJECT",Swig_var_AllocIntermedReqType_ACCOUNT_LEVEL_REJECT_get, Swig_var_AllocIntermedReqType_ACCOUNT_LEVEL_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_BLOCK_LEVEL_REJECT",Swig_var_AllocIntermedReqType_BLOCK_LEVEL_REJECT_get, Swig_var_AllocIntermedReqType_BLOCK_LEVEL_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_PENDING_ACCEPT",Swig_var_AllocIntermedReqType_PENDING_ACCEPT_get, Swig_var_AllocIntermedReqType_PENDING_ACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocIntermedReqType_ACCEPT",Swig_var_AllocIntermedReqType_ACCEPT_get, Swig_var_AllocIntermedReqType_ACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListTypeSource_GICS",Swig_var_SecurityListTypeSource_GICS_get, Swig_var_SecurityListTypeSource_GICS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListTypeSource_NAICS",Swig_var_SecurityListTypeSource_NAICS_get, Swig_var_SecurityListTypeSource_NAICS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListTypeSource_ICB",Swig_var_SecurityListTypeSource_ICB_get, Swig_var_SecurityListTypeSource_ICB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_OUTSTANDING_TRADES",Swig_var_CollInquiryQualifier_OUTSTANDING_TRADES_get, Swig_var_CollInquiryQualifier_OUTSTANDING_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_PARTIALLY_ASSIGNED",Swig_var_CollInquiryQualifier_PARTIALLY_ASSIGNED_get, Swig_var_CollInquiryQualifier_PARTIALLY_ASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_TRADE_DATE",Swig_var_CollInquiryQualifier_TRADE_DATE_get, Swig_var_CollInquiryQualifier_TRADE_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_FULLY_ASSIGNED",Swig_var_CollInquiryQualifier_FULLY_ASSIGNED_get, Swig_var_CollInquiryQualifier_FULLY_ASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_SUBSTITUTION_ELIGIBLE",Swig_var_CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_get, Swig_var_CollInquiryQualifier_SUBSTITUTION_ELIGIBLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_NOT_ASSIGNED",Swig_var_CollInquiryQualifier_NOT_ASSIGNED_get, Swig_var_CollInquiryQualifier_NOT_ASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_COLLATERAL_INSTRUMENT",Swig_var_CollInquiryQualifier_COLLATERAL_INSTRUMENT_get, Swig_var_CollInquiryQualifier_COLLATERAL_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_TRADEDATE",Swig_var_CollInquiryQualifier_TRADEDATE_get, Swig_var_CollInquiryQualifier_TRADEDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_COLLATERALINSTRUMENT",Swig_var_CollInquiryQualifier_COLLATERALINSTRUMENT_get, Swig_var_CollInquiryQualifier_COLLATERALINSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryQualifier_GC_INSTRUMENT",Swig_var_CollInquiryQualifier_GC_INSTRUMENT_get, Swig_var_CollInquiryQualifier_GC_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContingencyType_ONE_UPDATES_THE_OTHER_4",Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_4_get, Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContingencyType_ONE_TRIGGERS_THE_OTHER",Swig_var_ContingencyType_ONE_TRIGGERS_THE_OTHER_get, Swig_var_ContingencyType_ONE_TRIGGERS_THE_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContingencyType_ONE_CANCELS_THE_OTHER",Swig_var_ContingencyType_ONE_CANCELS_THE_OTHER_get, Swig_var_ContingencyType_ONE_CANCELS_THE_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContingencyType_ONE_UPDATES_THE_OTHER_3",Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_3_get, Swig_var_ContingencyType_ONE_UPDATES_THE_OTHER_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EmailType_NEW",Swig_var_EmailType_NEW_get, Swig_var_EmailType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EmailType_REPLY",Swig_var_EmailType_REPLY_get, Swig_var_EmailType_REPLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EmailType_ADMIN_REPLY",Swig_var_EmailType_ADMIN_REPLY_get, Swig_var_EmailType_ADMIN_REPLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQltyInd_MEDIUM",Swig_var_IOIQltyInd_MEDIUM_get, Swig_var_IOIQltyInd_MEDIUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQltyInd_HIGH",Swig_var_IOIQltyInd_HIGH_get, Swig_var_IOIQltyInd_HIGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQltyInd_LOW",Swig_var_IOIQltyInd_LOW_get, Swig_var_IOIQltyInd_LOW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY",Swig_var_MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY_get, Swig_var_MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY",Swig_var_MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_get, Swig_var_MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY",Swig_var_MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY_get, Swig_var_MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_HOUSE_TRADER",Swig_var_AccountType_HOUSE_TRADER_get, Swig_var_AccountType_HOUSE_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS",Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS_get, Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS",Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_get, Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_FLOOR_TRADER",Swig_var_AccountType_FLOOR_TRADER_get, Swig_var_AccountType_FLOOR_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_JOINT_BACK_OFFICE_ACCOUNT",Swig_var_AccountType_JOINT_BACK_OFFICE_ACCOUNT_get, Swig_var_AccountType_JOINT_BACK_OFFICE_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED",Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_get, Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS",Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_get, Swig_var_AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_JOINT_BACKOFFICE_ACCOUNT",Swig_var_AccountType_JOINT_BACKOFFICE_ACCOUNT_get, Swig_var_AccountType_JOINT_BACKOFFICE_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED",Swig_var_AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_get, Swig_var_AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonInt_ADDITIONAL_INFORMATION",Swig_var_HaltReasonInt_ADDITIONAL_INFORMATION_get, Swig_var_HaltReasonInt_ADDITIONAL_INFORMATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonInt_NEWS_PENDING",Swig_var_HaltReasonInt_NEWS_PENDING_get, Swig_var_HaltReasonInt_NEWS_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonInt_ORDER_INFLUX",Swig_var_HaltReasonInt_ORDER_INFLUX_get, Swig_var_HaltReasonInt_ORDER_INFLUX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonInt_NEWS_DISSEMINATION",Swig_var_HaltReasonInt_NEWS_DISSEMINATION_get, Swig_var_HaltReasonInt_NEWS_DISSEMINATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonInt_EQUIPMENT_CHANGEOVER",Swig_var_HaltReasonInt_EQUIPMENT_CHANGEOVER_get, Swig_var_HaltReasonInt_EQUIPMENT_CHANGEOVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonInt_ORDER_IMBALANCE",Swig_var_HaltReasonInt_ORDER_IMBALANCE_get, Swig_var_HaltReasonInt_ORDER_IMBALANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_106H_AND_106J_FIRMS",Swig_var_ClearingFeeIndicator_106H_AND_106J_FIRMS_get, Swig_var_ClearingFeeIndicator_106H_AND_106J_FIRMS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT",Swig_var_ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get, Swig_var_ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS",Swig_var_ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS_get, Swig_var_ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT",Swig_var_ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get, Swig_var_ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT",Swig_var_ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get, Swig_var_ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT",Swig_var_ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get, Swig_var_ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_LESSEE_106F_EMPLOYEES",Swig_var_ClearingFeeIndicator_LESSEE_106F_EMPLOYEES_get, Swig_var_ClearingFeeIndicator_LESSEE_106F_EMPLOYEES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER",Swig_var_ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_get, Swig_var_ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT",Swig_var_ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get, Swig_var_ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS",Swig_var_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS_get, Swig_var_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_CBOE_MEMBER",Swig_var_ClearingFeeIndicator_CBOE_MEMBER_get, Swig_var_ClearingFeeIndicator_CBOE_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT",Swig_var_ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get, Swig_var_ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT",Swig_var_ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get, Swig_var_ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES",Swig_var_ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES_get, Swig_var_ClearingFeeIndicator_LESSEE_AND_106F_EMPLOYEES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR",Swig_var_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_get, Swig_var_ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT",Swig_var_ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get, Swig_var_ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT",Swig_var_ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get, Swig_var_ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER",Swig_var_ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER_get, Swig_var_ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES",Swig_var_ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_get, Swig_var_ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_6TH_YEAR_AND_BEYOND_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT",Swig_var_ClearingFeeIndicator_6TH_YEAR_AND_BEYOND_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_get, Swig_var_ClearingFeeIndicator_6TH_YEAR_AND_BEYOND_DELEGATE_TRADING_FOR_HIS_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT",Swig_var_ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get, Swig_var_ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT",Swig_var_ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_get, Swig_var_ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidType_DISCLOSED_STYLE",Swig_var_BidType_DISCLOSED_STYLE_get, Swig_var_BidType_DISCLOSED_STYLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidType_NO_BIDDING_PROCESS",Swig_var_BidType_NO_BIDDING_PROCESS_get, Swig_var_BidType_NO_BIDDING_PROCESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidType_DISCLOSED_SYTLE",Swig_var_BidType_DISCLOSED_SYTLE_get, Swig_var_BidType_DISCLOSED_SYTLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidType_NON_DISCLOSED_STYLE",Swig_var_BidType_NON_DISCLOSED_STYLE_get, Swig_var_BidType_NON_DISCLOSED_STYLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_PER_SHARE",Swig_var_QuotePriceType_PER_SHARE_get, Swig_var_QuotePriceType_PER_SHARE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR",Swig_var_QuotePriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR_get, Swig_var_QuotePriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR",Swig_var_QuotePriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR_get, Swig_var_QuotePriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_YIELD",Swig_var_QuotePriceType_YIELD_get, Swig_var_QuotePriceType_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_PREMIUM",Swig_var_QuotePriceType_PREMIUM_get, Swig_var_QuotePriceType_PREMIUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_TED_YIELD",Swig_var_QuotePriceType_TED_YIELD_get, Swig_var_QuotePriceType_TED_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_FIXED_AMOUNT",Swig_var_QuotePriceType_FIXED_AMOUNT_get, Swig_var_QuotePriceType_FIXED_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_DISCOUNT",Swig_var_QuotePriceType_DISCOUNT_get, Swig_var_QuotePriceType_DISCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_YIELD_SPREAD",Swig_var_QuotePriceType_YIELD_SPREAD_get, Swig_var_QuotePriceType_YIELD_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_TED_PRICE",Swig_var_QuotePriceType_TED_PRICE_get, Swig_var_QuotePriceType_TED_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_PERCENT",Swig_var_QuotePriceType_PERCENT_get, Swig_var_QuotePriceType_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_SPREAD",Swig_var_QuotePriceType_SPREAD_get, Swig_var_QuotePriceType_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuotePriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK",Swig_var_QuotePriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_get, Swig_var_QuotePriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE",Swig_var_MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE_get, Swig_var_MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegPriceMethod_REVERSED_NET_PRICE",Swig_var_MultilegPriceMethod_REVERSED_NET_PRICE_get, Swig_var_MultilegPriceMethod_REVERSED_NET_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegPriceMethod_MULTIPLIED_PRICE",Swig_var_MultilegPriceMethod_MULTIPLIED_PRICE_get, Swig_var_MultilegPriceMethod_MULTIPLIED_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegPriceMethod_INDIVIDUAL",Swig_var_MultilegPriceMethod_INDIVIDUAL_get, Swig_var_MultilegPriceMethod_INDIVIDUAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegPriceMethod_YIELD_DIFFERENCE",Swig_var_MultilegPriceMethod_YIELD_DIFFERENCE_get, Swig_var_MultilegPriceMethod_YIELD_DIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegPriceMethod_NET_PRICE",Swig_var_MultilegPriceMethod_NET_PRICE_get, Swig_var_MultilegPriceMethod_NET_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListMethod_PRE_LISTED_ONLY",Swig_var_ListMethod_PRE_LISTED_ONLY_get, Swig_var_ListMethod_PRE_LISTED_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListMethod_USER_REQUESTED",Swig_var_ListMethod_USER_REQUESTED_get, Swig_var_ListMethod_USER_REQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDImplicitDelete_NO",Swig_var_MDImplicitDelete_NO_get, Swig_var_MDImplicitDelete_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDImplicitDelete_YES",Swig_var_MDImplicitDelete_YES_get, Swig_var_MDImplicitDelete_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoutingType_TARGET_LIST",Swig_var_RoutingType_TARGET_LIST_get, Swig_var_RoutingType_TARGET_LIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoutingType_TARGET_FIRM",Swig_var_RoutingType_TARGET_FIRM_get, Swig_var_RoutingType_TARGET_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoutingType_BLOCK_LIST",Swig_var_RoutingType_BLOCK_LIST_get, Swig_var_RoutingType_BLOCK_LIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoutingType_BLOCK_FIRM",Swig_var_RoutingType_BLOCK_FIRM_get, Swig_var_RoutingType_BLOCK_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidTradeType_AGENCY",Swig_var_BidTradeType_AGENCY_get, Swig_var_BidTradeType_AGENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidTradeType_VWAP_GUARANTEE",Swig_var_BidTradeType_VWAP_GUARANTEE_get, Swig_var_BidTradeType_VWAP_GUARANTEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidTradeType_RISK_TRADE",Swig_var_BidTradeType_RISK_TRADE_get, Swig_var_BidTradeType_RISK_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidTradeType_GUARANTEED_CLOSE",Swig_var_BidTradeType_GUARANTEED_CLOSE_get, Swig_var_BidTradeType_GUARANTEED_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_INCORRECT_ALLOCATED_QUANTITY",Swig_var_OrdRejReason_INCORRECT_ALLOCATED_QUANTITY_get, Swig_var_OrdRejReason_INCORRECT_ALLOCATED_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER",Swig_var_OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER_get, Swig_var_OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_ORDER_EXCEEDS_LIMIT",Swig_var_OrdRejReason_ORDER_EXCEEDS_LIMIT_get, Swig_var_OrdRejReason_ORDER_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_EXCHANGE_CLOSED",Swig_var_OrdRejReason_EXCHANGE_CLOSED_get, Swig_var_OrdRejReason_EXCHANGE_CLOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_SURVEILLENCE_OPTION",Swig_var_OrdRejReason_SURVEILLENCE_OPTION_get, Swig_var_OrdRejReason_SURVEILLENCE_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_UNKNOWN_ORDER",Swig_var_OrdRejReason_UNKNOWN_ORDER_get, Swig_var_OrdRejReason_UNKNOWN_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC",Swig_var_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get, Swig_var_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_DUPLICATE_ORDER",Swig_var_OrdRejReason_DUPLICATE_ORDER_get, Swig_var_OrdRejReason_DUPLICATE_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_TOO_LATE_TO_ENTER",Swig_var_OrdRejReason_TOO_LATE_TO_ENTER_get, Swig_var_OrdRejReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC12_SURVEILLENCE_OPTION",Swig_var_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC12_SURVEILLENCE_OPTION_get, Swig_var_OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC12_SURVEILLENCE_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_INCORRECT_QUANTITY",Swig_var_OrdRejReason_INCORRECT_QUANTITY_get, Swig_var_OrdRejReason_INCORRECT_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_INVALID_PRICE_INCREMENT",Swig_var_OrdRejReason_INVALID_PRICE_INCREMENT_get, Swig_var_OrdRejReason_INVALID_PRICE_INCREMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_UNKNOWN_ACCOUNT",Swig_var_OrdRejReason_UNKNOWN_ACCOUNT_get, Swig_var_OrdRejReason_UNKNOWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_INVALID_INVESTOR_ID",Swig_var_OrdRejReason_INVALID_INVESTOR_ID_get, Swig_var_OrdRejReason_INVALID_INVESTOR_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_UNKNOWN_SYMBOL",Swig_var_OrdRejReason_UNKNOWN_SYMBOL_get, Swig_var_OrdRejReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_OTHER",Swig_var_OrdRejReason_OTHER_get, Swig_var_OrdRejReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_BROKER",Swig_var_OrdRejReason_BROKER_get, Swig_var_OrdRejReason_BROKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_BROKER_OPTION",Swig_var_OrdRejReason_BROKER_OPTION_get, Swig_var_OrdRejReason_BROKER_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND",Swig_var_OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get, Swig_var_OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_TRADE_ALONG_REQUIRED",Swig_var_OrdRejReason_TRADE_ALONG_REQUIRED_get, Swig_var_OrdRejReason_TRADE_ALONG_REQUIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdRejReason_STALE_ORDER",Swig_var_OrdRejReason_STALE_ORDER_get, Swig_var_OrdRejReason_STALE_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MaturityMonthYearIncrementUnits_WEEKS",Swig_var_MaturityMonthYearIncrementUnits_WEEKS_get, Swig_var_MaturityMonthYearIncrementUnits_WEEKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MaturityMonthYearIncrementUnits_MONTHS",Swig_var_MaturityMonthYearIncrementUnits_MONTHS_get, Swig_var_MaturityMonthYearIncrementUnits_MONTHS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MaturityMonthYearIncrementUnits_YEARS",Swig_var_MaturityMonthYearIncrementUnits_YEARS_get, Swig_var_MaturityMonthYearIncrementUnits_YEARS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MaturityMonthYearIncrementUnits_DAYS",Swig_var_MaturityMonthYearIncrementUnits_DAYS_get, Swig_var_MaturityMonthYearIncrementUnits_DAYS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DisplayWhen_EXHAUST",Swig_var_DisplayWhen_EXHAUST_get, Swig_var_DisplayWhen_EXHAUST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DisplayWhen_IMMEDIATE",Swig_var_DisplayWhen_IMMEDIATE_get, Swig_var_DisplayWhen_IMMEDIATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueAction_END_SESSION",Swig_var_ApplQueueAction_END_SESSION_get, Swig_var_ApplQueueAction_END_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueAction_QUEUE_FLUSHED",Swig_var_ApplQueueAction_QUEUE_FLUSHED_get, Swig_var_ApplQueueAction_QUEUE_FLUSHED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueAction_OVERLAY_LAST",Swig_var_ApplQueueAction_OVERLAY_LAST_get, Swig_var_ApplQueueAction_OVERLAY_LAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueAction_NO_ACTION_TAKEN",Swig_var_ApplQueueAction_NO_ACTION_TAKEN_get, Swig_var_ApplQueueAction_NO_ACTION_TAKEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistTransType_REPLACE",Swig_var_RegistTransType_REPLACE_get, Swig_var_RegistTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistTransType_NEW",Swig_var_RegistTransType_NEW_get, Swig_var_RegistTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistTransType_CANCEL",Swig_var_RegistTransType_CANCEL_get, Swig_var_RegistTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PRODUCT_TICKS_IN_HALFS",Swig_var_PriceType_PRODUCT_TICKS_IN_HALFS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_HALFS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PER_SHARE",Swig_var_PriceType_PER_SHARE_get, Swig_var_PriceType_PER_SHARE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR",Swig_var_PriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR_get, Swig_var_PriceType_DISCOUNT_PERCENTAGE_POINTS_BELOW_PAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR",Swig_var_PriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR_get, Swig_var_PriceType_PREMIUM_PERCENTAGE_POINTS_OVER_PAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PRODUCT_TICKS_IN_FOURTHS",Swig_var_PriceType_PRODUCT_TICKS_IN_FOURTHS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_FOURTHS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_YIELD",Swig_var_PriceType_YIELD_get, Swig_var_PriceType_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_TED_YIELD",Swig_var_PriceType_TED_YIELD_get, Swig_var_PriceType_TED_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PREMIUM",Swig_var_PriceType_PREMIUM_get, Swig_var_PriceType_PREMIUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_FIXED_AMOUNT",Swig_var_PriceType_FIXED_AMOUNT_get, Swig_var_PriceType_FIXED_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_DISCOUNT",Swig_var_PriceType_DISCOUNT_get, Swig_var_PriceType_DISCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS",Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS",Swig_var_PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PERCENTAGE",Swig_var_PriceType_PERCENTAGE_get, Swig_var_PriceType_PERCENTAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PRODUCT_TICKS_IN_EIGHTS",Swig_var_PriceType_PRODUCT_TICKS_IN_EIGHTS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_EIGHTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS",Swig_var_PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PRODUCT_TICKS_IN_SIXTEENTHS",Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTEENTHS_get, Swig_var_PriceType_PRODUCT_TICKS_IN_SIXTEENTHS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_PER_UNIT",Swig_var_PriceType_PER_UNIT_get, Swig_var_PriceType_PER_UNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_VARIABLE_CABINET_TRADE_PRICE",Swig_var_PriceType_VARIABLE_CABINET_TRADE_PRICE_get, Swig_var_PriceType_VARIABLE_CABINET_TRADE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_TED_PRICE",Swig_var_PriceType_TED_PRICE_get, Swig_var_PriceType_TED_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_SPREAD",Swig_var_PriceType_SPREAD_get, Swig_var_PriceType_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_FIXED_CABINET_TRADE_PRICE",Swig_var_PriceType_FIXED_CABINET_TRADE_PRICE_get, Swig_var_PriceType_FIXED_CABINET_TRADE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK",Swig_var_PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_get, Swig_var_PriceType_BASIS_POINTS_RELATIVE_TO_BENCHMARK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligMode_PRELIMINARY",Swig_var_SettlObligMode_PRELIMINARY_get, Swig_var_SettlObligMode_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligMode_FINAL",Swig_var_SettlObligMode_FINAL_get, Swig_var_SettlObligMode_FINAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityUpdateAction_DELETE",Swig_var_SecurityUpdateAction_DELETE_get, Swig_var_SecurityUpdateAction_DELETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityUpdateAction_ADD",Swig_var_SecurityUpdateAction_ADD_get, Swig_var_SecurityUpdateAction_ADD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityUpdateAction_MODIFY",Swig_var_SecurityUpdateAction_MODIFY_get, Swig_var_SecurityUpdateAction_MODIFY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkRequestType_STOP_SUBSCRIBING",Swig_var_NetworkRequestType_STOP_SUBSCRIBING_get, Swig_var_NetworkRequestType_STOP_SUBSCRIBING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkRequestType_SUBSCRIBE",Swig_var_NetworkRequestType_SUBSCRIBE_get, Swig_var_NetworkRequestType_SUBSCRIBE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkRequestType_SNAPSHOT",Swig_var_NetworkRequestType_SNAPSHOT_get, Swig_var_NetworkRequestType_SNAPSHOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED",Swig_var_NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED_get, Swig_var_NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXECUTION_VENUE",Swig_var_PartyRole_EXECUTION_VENUE_get, Swig_var_PartyRole_EXECUTION_VENUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CLIENT_ID",Swig_var_PartyRole_CLIENT_ID_get, Swig_var_PartyRole_CLIENT_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_MARKET_DATA_ENTRY_ORIGINATOR",Swig_var_PartyRole_MARKET_DATA_ENTRY_ORIGINATOR_get, Swig_var_PartyRole_MARKET_DATA_ENTRY_ORIGINATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ORDER_ORIGINATION_FIRM",Swig_var_PartyRole_ORDER_ORIGINATION_FIRM_get, Swig_var_PartyRole_ORDER_ORIGINATION_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_PLEDGEE_ACCOUNT",Swig_var_PartyRole_PLEDGEE_ACCOUNT_get, Swig_var_PartyRole_PLEDGEE_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRA_TRADER",Swig_var_PartyRole_CONTRA_TRADER_get, Swig_var_PartyRole_CONTRA_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_MULTILATERAL_TRADING_FACILITY",Swig_var_PartyRole_MULTILATERAL_TRADING_FACILITY_get, Swig_var_PartyRole_MULTILATERAL_TRADING_FACILITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CENTRAL_REGISTRATION_DEPOSITORY",Swig_var_PartyRole_CENTRAL_REGISTRATION_DEPOSITORY_get, Swig_var_PartyRole_CENTRAL_REGISTRATION_DEPOSITORY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_REPORT_ORIGINATOR",Swig_var_PartyRole_REPORT_ORIGINATOR_get, Swig_var_PartyRole_REPORT_ORIGINATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_TRANSFER_TO_FIRM",Swig_var_PartyRole_TRANSFER_TO_FIRM_get, Swig_var_PartyRole_TRANSFER_TO_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_BROKERCLEARINGID",Swig_var_PartyRole_BROKERCLEARINGID_get, Swig_var_PartyRole_BROKERCLEARINGID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ASSET_MANAGER",Swig_var_PartyRole_ASSET_MANAGER_get, Swig_var_PartyRole_ASSET_MANAGER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INTRODUCING_BROKER",Swig_var_PartyRole_INTRODUCING_BROKER_get, Swig_var_PartyRole_INTRODUCING_BROKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_LOCATE_LENDING_FIRM",Swig_var_PartyRole_LOCATE_LENDING_FIRM_get, Swig_var_PartyRole_LOCATE_LENDING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRA_CLEARING_FIRM",Swig_var_PartyRole_CONTRA_CLEARING_FIRM_get, Swig_var_PartyRole_CONTRA_CLEARING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION",Swig_var_PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION_get, Swig_var_PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CUSTODIAN",Swig_var_PartyRole_CUSTODIAN_get, Swig_var_PartyRole_CUSTODIAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_GIVEUP_CLEARING_FIRM",Swig_var_PartyRole_GIVEUP_CLEARING_FIRM_get, Swig_var_PartyRole_GIVEUP_CLEARING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXECUTING_TRADER",Swig_var_PartyRole_EXECUTING_TRADER_get, Swig_var_PartyRole_EXECUTING_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXECUTING_UNIT",Swig_var_PartyRole_EXECUTING_UNIT_get, Swig_var_PartyRole_EXECUTING_UNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_BROKER_OF_CREDIT",Swig_var_PartyRole_BROKER_OF_CREDIT_get, Swig_var_PartyRole_BROKER_OF_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CORRESPONDANT_CLEARING_FIRM",Swig_var_PartyRole_CORRESPONDANT_CLEARING_FIRM_get, Swig_var_PartyRole_CORRESPONDANT_CLEARING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SETTLEMENT_LOCATION",Swig_var_PartyRole_SETTLEMENT_LOCATION_get, Swig_var_PartyRole_SETTLEMENT_LOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_THIRD_PARTY_ALLOCATION_FIRM",Swig_var_PartyRole_THIRD_PARTY_ALLOCATION_FIRM_get, Swig_var_PartyRole_THIRD_PARTY_ALLOCATION_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ORDER_ORIGINATION_TRADER",Swig_var_PartyRole_ORDER_ORIGINATION_TRADER_get, Swig_var_PartyRole_ORDER_ORIGINATION_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_HOST_COMPETENT_AUTHORITY",Swig_var_PartyRole_HOST_COMPETENT_AUTHORITY_get, Swig_var_PartyRole_HOST_COMPETENT_AUTHORITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ORDER_ENTRY_OPERATOR_ID",Swig_var_PartyRole_ORDER_ENTRY_OPERATOR_ID_get, Swig_var_PartyRole_ORDER_ENTRY_OPERATOR_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SPONSORING_FIRM",Swig_var_PartyRole_SPONSORING_FIRM_get, Swig_var_PartyRole_SPONSORING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INTRODUCING_FIRM",Swig_var_PartyRole_INTRODUCING_FIRM_get, Swig_var_PartyRole_INTRODUCING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CLEARING_FIRM",Swig_var_PartyRole_CLEARING_FIRM_get, Swig_var_PartyRole_CLEARING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRA_POSITION_ACCOUNT",Swig_var_PartyRole_CONTRA_POSITION_ACCOUNT_get, Swig_var_PartyRole_CONTRA_POSITION_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INVESTOR_ID",Swig_var_PartyRole_INVESTOR_ID_get, Swig_var_PartyRole_INVESTOR_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ENTERING_TRADER",Swig_var_PartyRole_ENTERING_TRADER_get, Swig_var_PartyRole_ENTERING_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_LOCATE",Swig_var_PartyRole_LOCATE_get, Swig_var_PartyRole_LOCATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT",Swig_var_PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT_get, Swig_var_PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY",Swig_var_PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY_get, Swig_var_PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES",Swig_var_PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES_get, Swig_var_PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_FORIEGN_FIRM",Swig_var_PartyRole_FORIEGN_FIRM_get, Swig_var_PartyRole_FORIEGN_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ACCEPTABLE_COUNTERPARTY",Swig_var_PartyRole_ACCEPTABLE_COUNTERPARTY_get, Swig_var_PartyRole_ACCEPTABLE_COUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CUSTOMER_ACCOUNT",Swig_var_PartyRole_CUSTOMER_ACCOUNT_get, Swig_var_PartyRole_CUSTOMER_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_POSITION_ACCOUNT",Swig_var_PartyRole_POSITION_ACCOUNT_get, Swig_var_PartyRole_POSITION_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_LIQUIDITY_PROVIDER",Swig_var_PartyRole_LIQUIDITY_PROVIDER_get, Swig_var_PartyRole_LIQUIDITY_PROVIDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_MARKET_MAKER",Swig_var_PartyRole_MARKET_MAKER_get, Swig_var_PartyRole_MARKET_MAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_AGENT",Swig_var_PartyRole_AGENT_get, Swig_var_PartyRole_AGENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ENTERING_UNIT",Swig_var_PartyRole_ENTERING_UNIT_get, Swig_var_PartyRole_ENTERING_UNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_FOREIGN_FIRM",Swig_var_PartyRole_FOREIGN_FIRM_get, Swig_var_PartyRole_FOREIGN_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CLEARING_ACCOUNT",Swig_var_PartyRole_CLEARING_ACCOUNT_get, Swig_var_PartyRole_CLEARING_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_HOME_COMPETENT_AUTHORITY",Swig_var_PartyRole_HOME_COMPETENT_AUTHORITY_get, Swig_var_PartyRole_HOME_COMPETENT_AUTHORITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INTERESTED_PARTY",Swig_var_PartyRole_INTERESTED_PARTY_get, Swig_var_PartyRole_INTERESTED_PARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SESSION_ID",Swig_var_PartyRole_SESSION_ID_get, Swig_var_PartyRole_SESSION_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_REPORTING_INTERMEDIARY",Swig_var_PartyRole_REPORTING_INTERMEDIARY_get, Swig_var_PartyRole_REPORTING_INTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INVESTMENT_FIRM",Swig_var_PartyRole_INVESTMENT_FIRM_get, Swig_var_PartyRole_INVESTMENT_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_TRADER_MNEMONIC",Swig_var_PartyRole_TRADER_MNEMONIC_get, Swig_var_PartyRole_TRADER_MNEMONIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INTERNAL_CARRY_ACCOUNT",Swig_var_PartyRole_INTERNAL_CARRY_ACCOUNT_get, Swig_var_PartyRole_INTERNAL_CARRY_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRA_FIRM",Swig_var_PartyRole_CONTRA_FIRM_get, Swig_var_PartyRole_CONTRA_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CORRESPONDENT_BROKER",Swig_var_PartyRole_CORRESPONDENT_BROKER_get, Swig_var_PartyRole_CORRESPONDENT_BROKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CLEARING_ORGANIZATION",Swig_var_PartyRole_CLEARING_ORGANIZATION_get, Swig_var_PartyRole_CLEARING_ORGANIZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SUB_CUSTODIAN",Swig_var_PartyRole_SUB_CUSTODIAN_get, Swig_var_PartyRole_SUB_CUSTODIAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_BUYER_SELLER",Swig_var_PartyRole_BUYER_SELLER_get, Swig_var_PartyRole_BUYER_SELLER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_STEP_OUT_FIRM",Swig_var_PartyRole_STEP_OUT_FIRM_get, Swig_var_PartyRole_STEP_OUT_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_MARKET_DATA_MARKET",Swig_var_PartyRole_MARKET_DATA_MARKET_get, Swig_var_PartyRole_MARKET_DATA_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXCHANGE",Swig_var_PartyRole_EXCHANGE_get, Swig_var_PartyRole_EXCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CLAIMING_ACCOUNT",Swig_var_PartyRole_CLAIMING_ACCOUNT_get, Swig_var_PartyRole_CLAIMING_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SECONDARY_ACCOUNT_NUMBER",Swig_var_PartyRole_SECONDARY_ACCOUNT_NUMBER_get, Swig_var_PartyRole_SECONDARY_ACCOUNT_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ALLOCATION_ENTITY",Swig_var_PartyRole_ALLOCATION_ENTITY_get, Swig_var_PartyRole_ALLOCATION_ENTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_INTERMEDIARY",Swig_var_PartyRole_INTERMEDIARY_get, Swig_var_PartyRole_INTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXECUTING_FIRM",Swig_var_PartyRole_EXECUTING_FIRM_get, Swig_var_PartyRole_EXECUTING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_LOCATION_ID",Swig_var_PartyRole_LOCATION_ID_get, Swig_var_PartyRole_LOCATION_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_DESK_ID",Swig_var_PartyRole_DESK_ID_get, Swig_var_PartyRole_DESK_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_EXECUTING_SYSTEM",Swig_var_PartyRole_EXECUTING_SYSTEM_get, Swig_var_PartyRole_EXECUTING_SYSTEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_BENEFICIARY",Swig_var_PartyRole_BENEFICIARY_get, Swig_var_PartyRole_BENEFICIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_FUND_MANAGER_CLIENT_ID",Swig_var_PartyRole_FUND_MANAGER_CLIENT_ID_get, Swig_var_PartyRole_FUND_MANAGER_CLIENT_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRA_INVESTOR_ID",Swig_var_PartyRole_CONTRA_INVESTOR_ID_get, Swig_var_PartyRole_CONTRA_INVESTOR_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_UNACCEPTABLE_COUNTERPARTY",Swig_var_PartyRole_UNACCEPTABLE_COUNTERPARTY_get, Swig_var_PartyRole_UNACCEPTABLE_COUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_UNDERLYING_CONTRA_FIRM",Swig_var_PartyRole_UNDERLYING_CONTRA_FIRM_get, Swig_var_PartyRole_UNDERLYING_CONTRA_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_QUOTE_ORIGINATOR",Swig_var_PartyRole_QUOTE_ORIGINATOR_get, Swig_var_PartyRole_QUOTE_ORIGINATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_REGULATED_MARKET",Swig_var_PartyRole_REGULATED_MARKET_get, Swig_var_PartyRole_REGULATED_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION",Swig_var_PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION_get, Swig_var_PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_ENTERING_FIRM",Swig_var_PartyRole_ENTERING_FIRM_get, Swig_var_PartyRole_ENTERING_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY",Swig_var_PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY_get, Swig_var_PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SENDER_LOCATION",Swig_var_PartyRole_SENDER_LOCATION_get, Swig_var_PartyRole_SENDER_LOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_SYSTEMATIC_INTERNALISER",Swig_var_PartyRole_SYSTEMATIC_INTERNALISER_get, Swig_var_PartyRole_SYSTEMATIC_INTERNALISER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_CONTRA_EXCHANGE",Swig_var_PartyRole_CONTRA_EXCHANGE_get, Swig_var_PartyRole_CONTRA_EXCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_REGULATORY_BODY",Swig_var_PartyRole_REGULATORY_BODY_get, Swig_var_PartyRole_REGULATORY_BODY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_PLEDGOR_ACCOUNT",Swig_var_PartyRole_PLEDGOR_ACCOUNT_get, Swig_var_PartyRole_PLEDGOR_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY",Swig_var_PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY_get, Swig_var_PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AssignmentMethod_PRO_RATA",Swig_var_AssignmentMethod_PRO_RATA_get, Swig_var_AssignmentMethod_PRO_RATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AssignmentMethod_RANDOM",Swig_var_AssignmentMethod_RANDOM_get, Swig_var_AssignmentMethod_RANDOM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AssignmentMethod_PRORATA",Swig_var_AssignmentMethod_PRORATA_get, Swig_var_AssignmentMethod_PRORATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_TZTIMEONLY",Swig_var_StrategyParameterType_TZTIMEONLY_get, Swig_var_StrategyParameterType_TZTIMEONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_MONTHYEAR",Swig_var_StrategyParameterType_MONTHYEAR_get, Swig_var_StrategyParameterType_MONTHYEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_PRICE",Swig_var_StrategyParameterType_PRICE_get, Swig_var_StrategyParameterType_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_QTY",Swig_var_StrategyParameterType_QTY_get, Swig_var_StrategyParameterType_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_BOOLEAN",Swig_var_StrategyParameterType_BOOLEAN_get, Swig_var_StrategyParameterType_BOOLEAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_MULTIPLECHARVALUE",Swig_var_StrategyParameterType_MULTIPLECHARVALUE_get, Swig_var_StrategyParameterType_MULTIPLECHARVALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_CHAR",Swig_var_StrategyParameterType_CHAR_get, Swig_var_StrategyParameterType_CHAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_NUMINGROUP",Swig_var_StrategyParameterType_NUMINGROUP_get, Swig_var_StrategyParameterType_NUMINGROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_TAGNUM",Swig_var_StrategyParameterType_TAGNUM_get, Swig_var_StrategyParameterType_TAGNUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_COUNTRY",Swig_var_StrategyParameterType_COUNTRY_get, Swig_var_StrategyParameterType_COUNTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_TENOR",Swig_var_StrategyParameterType_TENOR_get, Swig_var_StrategyParameterType_TENOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_LOCALMKTTIME",Swig_var_StrategyParameterType_LOCALMKTTIME_get, Swig_var_StrategyParameterType_LOCALMKTTIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_INT",Swig_var_StrategyParameterType_INT_get, Swig_var_StrategyParameterType_INT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_LOCALMKTDATE",Swig_var_StrategyParameterType_LOCALMKTDATE_get, Swig_var_StrategyParameterType_LOCALMKTDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_EXCHANGE",Swig_var_StrategyParameterType_EXCHANGE_get, Swig_var_StrategyParameterType_EXCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_LANGUAGE",Swig_var_StrategyParameterType_LANGUAGE_get, Swig_var_StrategyParameterType_LANGUAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_PERCENTAGE",Swig_var_StrategyParameterType_PERCENTAGE_get, Swig_var_StrategyParameterType_PERCENTAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_LENGTH",Swig_var_StrategyParameterType_LENGTH_get, Swig_var_StrategyParameterType_LENGTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_TZTIMESTAMP",Swig_var_StrategyParameterType_TZTIMESTAMP_get, Swig_var_StrategyParameterType_TZTIMESTAMP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_MULTIPLESTRINGVALUE",Swig_var_StrategyParameterType_MULTIPLESTRINGVALUE_get, Swig_var_StrategyParameterType_MULTIPLESTRINGVALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_UTCTIMESTAMP",Swig_var_StrategyParameterType_UTCTIMESTAMP_get, Swig_var_StrategyParameterType_UTCTIMESTAMP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_DATA",Swig_var_StrategyParameterType_DATA_get, Swig_var_StrategyParameterType_DATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_CURRENCY",Swig_var_StrategyParameterType_CURRENCY_get, Swig_var_StrategyParameterType_CURRENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_STRING",Swig_var_StrategyParameterType_STRING_get, Swig_var_StrategyParameterType_STRING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_AMT",Swig_var_StrategyParameterType_AMT_get, Swig_var_StrategyParameterType_AMT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_FLOAT",Swig_var_StrategyParameterType_FLOAT_get, Swig_var_StrategyParameterType_FLOAT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_UTCDATE",Swig_var_StrategyParameterType_UTCDATE_get, Swig_var_StrategyParameterType_UTCDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_UTCTIMEONLY",Swig_var_StrategyParameterType_UTCTIMEONLY_get, Swig_var_StrategyParameterType_UTCTIMEONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_SEQNUM",Swig_var_StrategyParameterType_SEQNUM_get, Swig_var_StrategyParameterType_SEQNUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_UTCDATEONLY",Swig_var_StrategyParameterType_UTCDATEONLY_get, Swig_var_StrategyParameterType_UTCDATEONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrategyParameterType_PRICEOFFSET",Swig_var_StrategyParameterType_PRICEOFFSET_get, Swig_var_StrategyParameterType_PRICEOFFSET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PGP_DES_MD5",Swig_var_EncryptMethod_PGP_DES_MD5_get, Swig_var_EncryptMethod_PGP_DES_MD5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PKCS_DES",Swig_var_EncryptMethod_PKCS_DES_get, Swig_var_EncryptMethod_PKCS_DES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PKCS",Swig_var_EncryptMethod_PKCS_get, Swig_var_EncryptMethod_PKCS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PGP_DES",Swig_var_EncryptMethod_PGP_DES_get, Swig_var_EncryptMethod_PGP_DES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_NONE",Swig_var_EncryptMethod_NONE_get, Swig_var_EncryptMethod_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_DES",Swig_var_EncryptMethod_DES_get, Swig_var_EncryptMethod_DES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_NONE_OTHER",Swig_var_EncryptMethod_NONE_OTHER_get, Swig_var_EncryptMethod_NONE_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EncryptMethod_PEM_DES_MD5",Swig_var_EncryptMethod_PEM_DES_MD5_get, Swig_var_EncryptMethod_PEM_DES_MD5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_ACCRUED_COUPON_AMOUNT",Swig_var_PosAmtType_ACCRUED_COUPON_AMOUNT_get, Swig_var_PosAmtType_ACCRUED_COUPON_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_PREMIUM_AMOUNT",Swig_var_PosAmtType_PREMIUM_AMOUNT_get, Swig_var_PosAmtType_PREMIUM_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET",Swig_var_PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET_get, Swig_var_PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_TOTAL_BANKED_AMOUNT",Swig_var_PosAmtType_TOTAL_BANKED_AMOUNT_get, Swig_var_PosAmtType_TOTAL_BANKED_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT",Swig_var_PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT_get, Swig_var_PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_SETTLEMENT_VALUE",Swig_var_PosAmtType_SETTLEMENT_VALUE_get, Swig_var_PosAmtType_SETTLEMENT_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_CASH_AMOUNT",Swig_var_PosAmtType_CASH_AMOUNT_get, Swig_var_PosAmtType_CASH_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_INITIAL_TRADE_COUPON_AMOUNT",Swig_var_PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_get, Swig_var_PosAmtType_INITIAL_TRADE_COUPON_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_INCREMENTAL_ACCRUED_COUPON",Swig_var_PosAmtType_INCREMENTAL_ACCRUED_COUPON_get, Swig_var_PosAmtType_INCREMENTAL_ACCRUED_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_VALUE_ADJUSTED_AMOUNT",Swig_var_PosAmtType_VALUE_ADJUSTED_AMOUNT_get, Swig_var_PosAmtType_VALUE_ADJUSTED_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT",Swig_var_PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT_get, Swig_var_PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_COLLATERALIZED_MARK_TO_MARKET",Swig_var_PosAmtType_COLLATERALIZED_MARK_TO_MARKET_get, Swig_var_PosAmtType_COLLATERALIZED_MARK_TO_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_CASH_RESIDUAL_AMOUNT",Swig_var_PosAmtType_CASH_RESIDUAL_AMOUNT_get, Swig_var_PosAmtType_CASH_RESIDUAL_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_COMPENSATION_AMOUNT",Swig_var_PosAmtType_COMPENSATION_AMOUNT_get, Swig_var_PosAmtType_COMPENSATION_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_TRADE_VARIATION_AMOUNT",Swig_var_PosAmtType_TRADE_VARIATION_AMOUNT_get, Swig_var_PosAmtType_TRADE_VARIATION_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_COUPON_AMOUNT",Swig_var_PosAmtType_COUPON_AMOUNT_get, Swig_var_PosAmtType_COUPON_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_TOTAL_COLLATERALIZED_AMOUNT",Swig_var_PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_get, Swig_var_PosAmtType_TOTAL_COLLATERALIZED_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT",Swig_var_PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT_get, Swig_var_PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ResetSeqNumFlag_NO",Swig_var_ResetSeqNumFlag_NO_get, Swig_var_ResetSeqNumFlag_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ResetSeqNumFlag_YES",Swig_var_ResetSeqNumFlag_YES_get, Swig_var_ResetSeqNumFlag_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED",Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED_get, Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALID_DESTINATION_REQUESTED",Swig_var_CollInquiryResult_INVALID_DESTINATION_REQUESTED_get, Swig_var_CollInquiryResult_INVALID_DESTINATION_REQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY",Swig_var_CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY_get, Swig_var_CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE",Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE_get, Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_SUCCESSFUL",Swig_var_CollInquiryResult_SUCCESSFUL_get, Swig_var_CollInquiryResult_SUCCESSFUL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_OTHER",Swig_var_CollInquiryResult_OTHER_get, Swig_var_CollInquiryResult_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED",Swig_var_CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED_get, Swig_var_CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT",Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT_get, Swig_var_CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALID_PARTIES",Swig_var_CollInquiryResult_INVALID_PARTIES_get, Swig_var_CollInquiryResult_INVALID_PARTIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED",Swig_var_CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED_get, Swig_var_CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED",Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED_get, Swig_var_CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRespType_DECLINED",Swig_var_CollAsgnRespType_DECLINED_get, Swig_var_CollAsgnRespType_DECLINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRespType_RECEIVED",Swig_var_CollAsgnRespType_RECEIVED_get, Swig_var_CollAsgnRespType_RECEIVED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRespType_REJECTED",Swig_var_CollAsgnRespType_REJECTED_get, Swig_var_CollAsgnRespType_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRespType_ACCEPTED",Swig_var_CollAsgnRespType_ACCEPTED_get, Swig_var_CollAsgnRespType_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnsolicitedIndicator_NO",Swig_var_UnsolicitedIndicator_NO_get, Swig_var_UnsolicitedIndicator_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnsolicitedIndicator_YES",Swig_var_UnsolicitedIndicator_YES_get, Swig_var_UnsolicitedIndicator_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_INVALID_PRICE",Swig_var_QuoteEntryRejectReason_INVALID_PRICE_get, Swig_var_QuoteEntryRejectReason_INVALID_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY",Swig_var_QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get, Swig_var_QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_TOO_LATE_TO_ENTER",Swig_var_QuoteEntryRejectReason_TOO_LATE_TO_ENTER_get, Swig_var_QuoteEntryRejectReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT",Swig_var_QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT_get, Swig_var_QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_EXCHANGE",Swig_var_QuoteEntryRejectReason_EXCHANGE_get, Swig_var_QuoteEntryRejectReason_EXCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_UNKNOWN_SYMBOL",Swig_var_QuoteEntryRejectReason_UNKNOWN_SYMBOL_get, Swig_var_QuoteEntryRejectReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD",Swig_var_QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD_get, Swig_var_QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_UNKNOWN_QUOTE",Swig_var_QuoteEntryRejectReason_UNKNOWN_QUOTE_get, Swig_var_QuoteEntryRejectReason_UNKNOWN_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryRejectReason_DUPLICATE_QUOTE",Swig_var_QuoteEntryRejectReason_DUPLICATE_QUOTE_get, Swig_var_QuoteEntryRejectReason_DUPLICATE_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCapacity_PROPRIETARY",Swig_var_OrderCapacity_PROPRIETARY_get, Swig_var_OrderCapacity_PROPRIETARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCapacity_RISKLESS_PRINCIPAL",Swig_var_OrderCapacity_RISKLESS_PRINCIPAL_get, Swig_var_OrderCapacity_RISKLESS_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCapacity_AGENT_FOR_OTHER_MEMBER",Swig_var_OrderCapacity_AGENT_FOR_OTHER_MEMBER_get, Swig_var_OrderCapacity_AGENT_FOR_OTHER_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCapacity_PRINCIPAL",Swig_var_OrderCapacity_PRINCIPAL_get, Swig_var_OrderCapacity_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCapacity_AGENCY",Swig_var_OrderCapacity_AGENCY_get, Swig_var_OrderCapacity_AGENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCapacity_INDIVIDUAL",Swig_var_OrderCapacity_INDIVIDUAL_get, Swig_var_OrderCapacity_INDIVIDUAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteAckStatus_CANCELED_FOR_UNDERLYING",Swig_var_QuoteAckStatus_CANCELED_FOR_UNDERLYING_get, Swig_var_QuoteAckStatus_CANCELED_FOR_UNDERLYING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteAckStatus_CANCELED_ALL",Swig_var_QuoteAckStatus_CANCELED_ALL_get, Swig_var_QuoteAckStatus_CANCELED_ALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE",Swig_var_QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE_get, Swig_var_QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteAckStatus_REJECTED",Swig_var_QuoteAckStatus_REJECTED_get, Swig_var_QuoteAckStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteAckStatus_CANCELED_FOR_SYMBOL",Swig_var_QuoteAckStatus_CANCELED_FOR_SYMBOL_get, Swig_var_QuoteAckStatus_CANCELED_FOR_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteAckStatus_ACCEPTED",Swig_var_QuoteAckStatus_ACCEPTED_get, Swig_var_QuoteAckStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_CHANGE_PASSWORD_FOR_USER",Swig_var_UserRequestType_CHANGE_PASSWORD_FOR_USER_get, Swig_var_UserRequestType_CHANGE_PASSWORD_FOR_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_CHANGEPASSWORDFORUSER",Swig_var_UserRequestType_CHANGEPASSWORDFORUSER_get, Swig_var_UserRequestType_CHANGEPASSWORDFORUSER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_LOGOFFUSER",Swig_var_UserRequestType_LOGOFFUSER_get, Swig_var_UserRequestType_LOGOFFUSER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_LOG_OFF_USER",Swig_var_UserRequestType_LOG_OFF_USER_get, Swig_var_UserRequestType_LOG_OFF_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS",Swig_var_UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS_get, Swig_var_UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_LOGONUSER",Swig_var_UserRequestType_LOGONUSER_get, Swig_var_UserRequestType_LOGONUSER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserRequestType_LOG_ON_USER",Swig_var_UserRequestType_LOG_ON_USER_get, Swig_var_UserRequestType_LOG_ON_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportTransType_REPLACE",Swig_var_TradeReportTransType_REPLACE_get, Swig_var_TradeReportTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportTransType_NEW",Swig_var_TradeReportTransType_NEW_get, Swig_var_TradeReportTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportTransType_REVERSE",Swig_var_TradeReportTransType_REVERSE_get, Swig_var_TradeReportTransType_REVERSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportTransType_CANCEL",Swig_var_TradeReportTransType_CANCEL_get, Swig_var_TradeReportTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE",Swig_var_TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE_get, Swig_var_TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportTransType_RELEASE",Swig_var_TradeReportTransType_RELEASE_get, Swig_var_TradeReportTransType_RELEASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvSide_CROSS",Swig_var_AdvSide_CROSS_get, Swig_var_AdvSide_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvSide_TRADE",Swig_var_AdvSide_TRADE_get, Swig_var_AdvSide_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvSide_BUY",Swig_var_AdvSide_BUY_get, Swig_var_AdvSide_BUY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvSide_SELL",Swig_var_AdvSide_SELL_get, Swig_var_AdvSide_SELL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CoveredOrUncovered_COVERED",Swig_var_CoveredOrUncovered_COVERED_get, Swig_var_CoveredOrUncovered_COVERED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CoveredOrUncovered_UNCOVERED",Swig_var_CoveredOrUncovered_UNCOVERED_get, Swig_var_CoveredOrUncovered_UNCOVERED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_TFM",Swig_var_AcctIDSource_TFM_get, Swig_var_AcctIDSource_TFM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_BIC",Swig_var_AcctIDSource_BIC_get, Swig_var_AcctIDSource_BIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_OTHER",Swig_var_AcctIDSource_OTHER_get, Swig_var_AcctIDSource_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_OMGEO",Swig_var_AcctIDSource_OMGEO_get, Swig_var_AcctIDSource_OMGEO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_DTCC_CODE",Swig_var_AcctIDSource_DTCC_CODE_get, Swig_var_AcctIDSource_DTCC_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AcctIDSource_SID_CODE",Swig_var_AcctIDSource_SID_CODE_get, Swig_var_AcctIDSource_SID_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA",Swig_var_TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA_get, Swig_var_TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_ALL_TRADES",Swig_var_TradeRequestType_ALL_TRADES_get, Swig_var_TradeRequestType_ALL_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST",Swig_var_TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST_get, Swig_var_TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA",Swig_var_TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA_get, Swig_var_TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA",Swig_var_TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA_get, Swig_var_TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_HALTED",Swig_var_TradSesStatus_HALTED_get, Swig_var_TradSesStatus_HALTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_REQUEST_REJECTED",Swig_var_TradSesStatus_REQUEST_REJECTED_get, Swig_var_TradSesStatus_REQUEST_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_OPEN",Swig_var_TradSesStatus_OPEN_get, Swig_var_TradSesStatus_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_PRE_OPEN",Swig_var_TradSesStatus_PRE_OPEN_get, Swig_var_TradSesStatus_PRE_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_UNKNOWN",Swig_var_TradSesStatus_UNKNOWN_get, Swig_var_TradSesStatus_UNKNOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_PRE_CLOSE",Swig_var_TradSesStatus_PRE_CLOSE_get, Swig_var_TradSesStatus_PRE_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatus_CLOSED",Swig_var_TradSesStatus_CLOSED_get, Swig_var_TradSesStatus_CLOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_LAST_PEG",Swig_var_PegPriceType_LAST_PEG_get, Swig_var_PegPriceType_LAST_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_PRIMARY_PEG",Swig_var_PegPriceType_PRIMARY_PEG_get, Swig_var_PegPriceType_PRIMARY_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_OPENING_PEG",Swig_var_PegPriceType_OPENING_PEG_get, Swig_var_PegPriceType_OPENING_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER",Swig_var_PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get, Swig_var_PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_TRAILING_STOP_PEG",Swig_var_PegPriceType_TRAILING_STOP_PEG_get, Swig_var_PegPriceType_TRAILING_STOP_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_PEG_TO_LIMIT_PRICE",Swig_var_PegPriceType_PEG_TO_LIMIT_PRICE_get, Swig_var_PegPriceType_PEG_TO_LIMIT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_MID_PRICE_PEG",Swig_var_PegPriceType_MID_PRICE_PEG_get, Swig_var_PegPriceType_MID_PRICE_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_MARKET_PEG",Swig_var_PegPriceType_MARKET_PEG_get, Swig_var_PegPriceType_MARKET_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegPriceType_PEG_TO_VWAP",Swig_var_PegPriceType_PEG_TO_VWAP_get, Swig_var_PegPriceType_PEG_TO_VWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnRejReason_NO_AVAILABLE_STREAM",Swig_var_StreamAsgnRejReason_NO_AVAILABLE_STREAM_get, Swig_var_StreamAsgnRejReason_NO_AVAILABLE_STREAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE",Swig_var_StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE_get, Swig_var_StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnRejReason_UNKNOWN_CLIENT",Swig_var_StreamAsgnRejReason_UNKNOWN_CLIENT_get, Swig_var_StreamAsgnRejReason_UNKNOWN_CLIENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR",Swig_var_StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR_get, Swig_var_StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnRejReason_OTHER",Swig_var_StreamAsgnRejReason_OTHER_get, Swig_var_StreamAsgnRejReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT",Swig_var_ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get, Swig_var_ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ValuationMethod_PREMIUM_STYLE",Swig_var_ValuationMethod_PREMIUM_STYLE_get, Swig_var_ValuationMethod_PREMIUM_STYLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ValuationMethod_CDS_IN_DELIVERY",Swig_var_ValuationMethod_CDS_IN_DELIVERY_get, Swig_var_ValuationMethod_CDS_IN_DELIVERY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON",Swig_var_ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON_get, Swig_var_ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET",Swig_var_ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get, Swig_var_ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerType_SPECIFIED_TRADING_SESSION",Swig_var_TriggerType_SPECIFIED_TRADING_SESSION_get, Swig_var_TriggerType_SPECIFIED_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerType_NEXT_AUCTION",Swig_var_TriggerType_NEXT_AUCTION_get, Swig_var_TriggerType_NEXT_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerType_PRICE_MOVEMENT",Swig_var_TriggerType_PRICE_MOVEMENT_get, Swig_var_TriggerType_PRICE_MOVEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerType_PARTIAL_EXECUTION",Swig_var_TriggerType_PARTIAL_EXECUTION_get, Swig_var_TriggerType_PARTIAL_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceProtectionScope_LOCAL",Swig_var_PriceProtectionScope_LOCAL_get, Swig_var_PriceProtectionScope_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceProtectionScope_NONE",Swig_var_PriceProtectionScope_NONE_get, Swig_var_PriceProtectionScope_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceProtectionScope_GLOBAL",Swig_var_PriceProtectionScope_GLOBAL_get, Swig_var_PriceProtectionScope_GLOBAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceProtectionScope_NATIONAL",Swig_var_PriceProtectionScope_NATIONAL_get, Swig_var_PriceProtectionScope_NATIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_INVALID_PARTY_INFORMATION",Swig_var_TradeReportRejectReason_INVALID_PARTY_INFORMATION_get, Swig_var_TradeReportRejectReason_INVALID_PARTY_INFORMATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES",Swig_var_TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES_get, Swig_var_TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_INVALID_PARTY_ONFORMATION",Swig_var_TradeReportRejectReason_INVALID_PARTY_ONFORMATION_get, Swig_var_TradeReportRejectReason_INVALID_PARTY_ONFORMATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_UNKNOWN_INSTRUMENT",Swig_var_TradeReportRejectReason_UNKNOWN_INSTRUMENT_get, Swig_var_TradeReportRejectReason_UNKNOWN_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_SUCCESSFUL",Swig_var_TradeReportRejectReason_SUCCESSFUL_get, Swig_var_TradeReportRejectReason_SUCCESSFUL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_OTHER",Swig_var_TradeReportRejectReason_OTHER_get, Swig_var_TradeReportRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportRejectReason_INVALID_TRADE_TYPE",Swig_var_TradeReportRejectReason_INVALID_TRADE_TYPE_get, Swig_var_TradeReportRejectReason_INVALID_TRADE_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListType_NEWSPAPER_LIST",Swig_var_SecurityListType_NEWSPAPER_LIST_get, Swig_var_SecurityListType_NEWSPAPER_LIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListType_TRADING_LIST",Swig_var_SecurityListType_TRADING_LIST_get, Swig_var_SecurityListType_TRADING_LIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListType_INDUSTRY_CLASSIFICATION",Swig_var_SecurityListType_INDUSTRY_CLASSIFICATION_get, Swig_var_SecurityListType_INDUSTRY_CLASSIFICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListType_MARKET",Swig_var_SecurityListType_MARKET_get, Swig_var_SecurityListType_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_QUOTE_LOCKED",Swig_var_QuoteRejectReason_QUOTE_LOCKED_get, Swig_var_QuoteRejectReason_QUOTE_LOCKED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY",Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_INVALID_PRICE",Swig_var_QuoteRejectReason_INVALID_PRICE_get, Swig_var_QuoteRejectReason_INVALID_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY",Swig_var_QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_get, Swig_var_QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_TOO_LATE_TO_ENTER",Swig_var_QuoteRejectReason_TOO_LATE_TO_ENTER_get, Swig_var_QuoteRejectReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_EXCHANGE",Swig_var_QuoteRejectReason_EXCHANGE_get, Swig_var_QuoteRejectReason_EXCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_UNKNOWN_SYMBOL",Swig_var_QuoteRejectReason_UNKNOWN_SYMBOL_get, Swig_var_QuoteRejectReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_OTHER",Swig_var_QuoteRejectReason_OTHER_get, Swig_var_QuoteRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_INVALID_BID_ASK_SPREAD",Swig_var_QuoteRejectReason_INVALID_BID_ASK_SPREAD_get, Swig_var_QuoteRejectReason_INVALID_BID_ASK_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_UNKNOWN_QUOTE",Swig_var_QuoteRejectReason_UNKNOWN_QUOTE_get, Swig_var_QuoteRejectReason_UNKNOWN_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER",Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get, Swig_var_QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_DUPLICATE_QUOTE",Swig_var_QuoteRejectReason_DUPLICATE_QUOTE_get, Swig_var_QuoteRejectReason_DUPLICATE_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND",Swig_var_QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get, Swig_var_QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT",Swig_var_QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get, Swig_var_QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PossResend_NO",Swig_var_PossResend_NO_get, Swig_var_PossResend_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PossResend_YES",Swig_var_PossResend_YES_get, Swig_var_PossResend_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_SHARES",Swig_var_QuantityType_SHARES_get, Swig_var_QuantityType_SHARES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_CURRENTFACE",Swig_var_QuantityType_CURRENTFACE_get, Swig_var_QuantityType_CURRENTFACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_PAR",Swig_var_QuantityType_PAR_get, Swig_var_QuantityType_PAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_BONDS",Swig_var_QuantityType_BONDS_get, Swig_var_QuantityType_BONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_ORIGINALFACE",Swig_var_QuantityType_ORIGINALFACE_get, Swig_var_QuantityType_ORIGINALFACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_CONTRACTS",Swig_var_QuantityType_CONTRACTS_get, Swig_var_QuantityType_CONTRACTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_OTHER",Swig_var_QuantityType_OTHER_get, Swig_var_QuantityType_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuantityType_CURRENCY",Swig_var_QuantityType_CURRENCY_get, Swig_var_QuantityType_CURRENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE",Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_get, Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE",Swig_var_ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE_get, Swig_var_ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE",Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE_get, Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE",Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE_get, Swig_var_ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE",Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_get, Swig_var_ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT",Swig_var_ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT_get, Swig_var_ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ImpliedMarketIndicator_NOT_IMPLIED",Swig_var_ImpliedMarketIndicator_NOT_IMPLIED_get, Swig_var_ImpliedMarketIndicator_NOT_IMPLIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ImpliedMarketIndicator_IMPLIED_OUT",Swig_var_ImpliedMarketIndicator_IMPLIED_OUT_get, Swig_var_ImpliedMarketIndicator_IMPLIED_OUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ImpliedMarketIndicator_IMPLIED_IN",Swig_var_ImpliedMarketIndicator_IMPLIED_IN_get, Swig_var_ImpliedMarketIndicator_IMPLIED_IN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestType_AUTOMATIC",Swig_var_QuoteRequestType_AUTOMATIC_get, Swig_var_QuoteRequestType_AUTOMATIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestType_MANUAL",Swig_var_QuoteRequestType_MANUAL_get, Swig_var_QuoteRequestType_MANUAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA",Swig_var_SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA_get, Swig_var_SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA",Swig_var_SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA_get, Swig_var_SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE",Swig_var_SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE_get, Swig_var_SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_VALID_REQUEST",Swig_var_SecurityRequestResult_VALID_REQUEST_get, Swig_var_SecurityRequestResult_VALID_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST",Swig_var_SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_get, Swig_var_SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED",Swig_var_SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED_get, Swig_var_SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_ISSUER_HOLDING",Swig_var_OrderRestrictions_ISSUER_HOLDING_get, Swig_var_OrderRestrictions_ISSUER_HOLDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY",Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY_get, Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_NON_ALGORITHMIC",Swig_var_OrderRestrictions_NON_ALGORITHMIC_get, Swig_var_OrderRestrictions_NON_ALGORITHMIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE",Swig_var_OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE_get, Swig_var_OrderRestrictions_EXTNERAL_INTER_CONNECTED_MARKET_LINKAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_NON_INDEX_ARBITRAGE",Swig_var_OrderRestrictions_NON_INDEX_ARBITRAGE_get, Swig_var_OrderRestrictions_NON_INDEX_ARBITRAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_ACTING_AS_MARKET_MAKER_OF_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SEUCIRTY",Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OF_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SEUCIRTY_get, Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OF_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SEUCIRTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_PROGRAM_TRADE",Swig_var_OrderRestrictions_PROGRAM_TRADE_get, Swig_var_OrderRestrictions_PROGRAM_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_ISSUE_PRICE_STABILIZATION",Swig_var_OrderRestrictions_ISSUE_PRICE_STABILIZATION_get, Swig_var_OrderRestrictions_ISSUE_PRICE_STABILIZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_CROSS",Swig_var_OrderRestrictions_CROSS_get, Swig_var_OrderRestrictions_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE",Swig_var_OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE_get, Swig_var_OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_FOREIGN_ENTITY",Swig_var_OrderRestrictions_FOREIGN_ENTITY_get, Swig_var_OrderRestrictions_FOREIGN_ENTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_INDEX_ARBITRAGE",Swig_var_OrderRestrictions_INDEX_ARBITRAGE_get, Swig_var_OrderRestrictions_INDEX_ARBITRAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT",Swig_var_OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT_get, Swig_var_OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_ALGORITHMIC",Swig_var_OrderRestrictions_ALGORITHMIC_get, Swig_var_OrderRestrictions_ALGORITHMIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY",Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY_get, Swig_var_OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_RISKLESS_ARBITRAGE",Swig_var_OrderRestrictions_RISKLESS_ARBITRAGE_get, Swig_var_OrderRestrictions_RISKLESS_ARBITRAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderRestrictions_COMPETING_MARKET_MAKER",Swig_var_OrderRestrictions_COMPETING_MARKET_MAKER_get, Swig_var_OrderRestrictions_COMPETING_MARKET_MAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION",Swig_var_ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION_get, Swig_var_ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN",Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN_get, Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_SELL_DRIVEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW",Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW_get, Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_WITHDRAW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3",Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3_get, Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_IMMEDIATE",Swig_var_ListExecInstType_IMMEDIATE_get, Swig_var_ListExecInstType_IMMEDIATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4",Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4_get, Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5",Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5_get, Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP",Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP_get, Swig_var_ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_BUY_DRIVEN_CASH_TOP_UP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION",Swig_var_ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION_get, Swig_var_ListExecInstType_WAIT_FOR_EXECUTE_INSTRUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_FED_WIRE",Swig_var_DistribPaymentMethod_FED_WIRE_get, Swig_var_DistribPaymentMethod_FED_WIRE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_EUROCLEAR",Swig_var_DistribPaymentMethod_EUROCLEAR_get, Swig_var_DistribPaymentMethod_EUROCLEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_ACH_CREDIT",Swig_var_DistribPaymentMethod_ACH_CREDIT_get, Swig_var_DistribPaymentMethod_ACH_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_TELEGRAPHIC_TRANSFER",Swig_var_DistribPaymentMethod_TELEGRAPHIC_TRANSFER_get, Swig_var_DistribPaymentMethod_TELEGRAPHIC_TRANSFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_FEDWIRE",Swig_var_DistribPaymentMethod_FEDWIRE_get, Swig_var_DistribPaymentMethod_FEDWIRE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_CHEQUE",Swig_var_DistribPaymentMethod_CHEQUE_get, Swig_var_DistribPaymentMethod_CHEQUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_DIRECT_CREDIT",Swig_var_DistribPaymentMethod_DIRECT_CREDIT_get, Swig_var_DistribPaymentMethod_DIRECT_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_CREST",Swig_var_DistribPaymentMethod_CREST_get, Swig_var_DistribPaymentMethod_CREST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM",Swig_var_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_get, Swig_var_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_CLEARSTREAM",Swig_var_DistribPaymentMethod_CLEARSTREAM_get, Swig_var_DistribPaymentMethod_CLEARSTREAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_BPAY",Swig_var_DistribPaymentMethod_BPAY_get, Swig_var_DistribPaymentMethod_BPAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_NSCC",Swig_var_DistribPaymentMethod_NSCC_get, Swig_var_DistribPaymentMethod_NSCC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS",Swig_var_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS_get, Swig_var_DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DistribPaymentMethod_REINVEST_IN_FUND",Swig_var_DistribPaymentMethod_REINVEST_IN_FUND_get, Swig_var_DistribPaymentMethod_REINVEST_IN_FUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderHandlingInstSource_NASD_OATS",Swig_var_OrderHandlingInstSource_NASD_OATS_get, Swig_var_OrderHandlingInstSource_NASD_OATS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AffirmStatus_AFFIRMED",Swig_var_AffirmStatus_AFFIRMED_get, Swig_var_AffirmStatus_AFFIRMED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED",Swig_var_AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED_get, Swig_var_AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AffirmStatus_RECEIVED",Swig_var_AffirmStatus_RECEIVED_get, Swig_var_AffirmStatus_RECEIVED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT",Swig_var_OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get, Swig_var_OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT",Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get, Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER",Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get, Swig_var_OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrigCustOrderCapacity_ALL_OTHER",Swig_var_OrigCustOrderCapacity_ALL_OTHER_get, Swig_var_OrigCustOrderCapacity_ALL_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocMethod_GUARANTOR",Swig_var_AllocMethod_GUARANTOR_get, Swig_var_AllocMethod_GUARANTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocMethod_AUTOMATIC",Swig_var_AllocMethod_AUTOMATIC_get, Swig_var_AllocMethod_AUTOMATIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocMethod_MANUAL",Swig_var_AllocMethod_MANUAL_get, Swig_var_AllocMethod_MANUAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY",Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY",Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP",Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET",Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT",Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE",Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION",Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY",Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ALL_ORDERS",Swig_var_MassCancelResponse_CANCEL_ALL_ORDERS_get, Swig_var_MassCancelResponse_CANCEL_ALL_ORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_REQUEST_REJECTED",Swig_var_MassCancelResponse_CANCEL_REQUEST_REJECTED_get, Swig_var_MassCancelResponse_CANCEL_REQUEST_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER",Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE",Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT",Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT_get, Swig_var_MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER",Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER_get, Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER",Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER_get, Swig_var_StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE",Swig_var_SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE_get, Swig_var_SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN",Swig_var_SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN_get, Swig_var_SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExDestinationIDSource_PROPRIETARY",Swig_var_ExDestinationIDSource_PROPRIETARY_get, Swig_var_ExDestinationIDSource_PROPRIETARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER",Swig_var_ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_get, Swig_var_ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExDestinationIDSource_BIC",Swig_var_ExDestinationIDSource_BIC_get, Swig_var_ExDestinationIDSource_BIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExDestinationIDSource_MIC",Swig_var_ExDestinationIDSource_MIC_get, Swig_var_ExDestinationIDSource_MIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExDestinationIDSource_ISO_COUNTRY_CODE",Swig_var_ExDestinationIDSource_ISO_COUNTRY_CODE_get, Swig_var_ExDestinationIDSource_ISO_COUNTRY_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID",Swig_var_SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get, Swig_var_SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListRequestType_SYMBOL",Swig_var_SecurityListRequestType_SYMBOL_get, Swig_var_SecurityListRequestType_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE",Swig_var_SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_get, Swig_var_SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListRequestType_TRADINGSESSIONID",Swig_var_SecurityListRequestType_TRADINGSESSIONID_get, Swig_var_SecurityListRequestType_TRADINGSESSIONID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListRequestType_ALL_SECURITIES",Swig_var_SecurityListRequestType_ALL_SECURITIES_get, Swig_var_SecurityListRequestType_ALL_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityListRequestType_PRODUCT",Swig_var_SecurityListRequestType_PRODUCT_get, Swig_var_SecurityListRequestType_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_TIME_WARNING",Swig_var_CollAsgnReason_TIME_WARNING_get, Swig_var_CollAsgnReason_TIME_WARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_ADVERSE_TAX_EVENT",Swig_var_CollAsgnReason_ADVERSE_TAX_EVENT_get, Swig_var_CollAsgnReason_ADVERSE_TAX_EVENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_MARGIN_DEFICIENCY",Swig_var_CollAsgnReason_MARGIN_DEFICIENCY_get, Swig_var_CollAsgnReason_MARGIN_DEFICIENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_SCHEDULED",Swig_var_CollAsgnReason_SCHEDULED_get, Swig_var_CollAsgnReason_SCHEDULED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_INITIAL",Swig_var_CollAsgnReason_INITIAL_get, Swig_var_CollAsgnReason_INITIAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_FORWARD_COLLATERAL_DEMAND",Swig_var_CollAsgnReason_FORWARD_COLLATERAL_DEMAND_get, Swig_var_CollAsgnReason_FORWARD_COLLATERAL_DEMAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_EVENT_OF_DEFAULT",Swig_var_CollAsgnReason_EVENT_OF_DEFAULT_get, Swig_var_CollAsgnReason_EVENT_OF_DEFAULT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnReason_MARGIN_EXCESS",Swig_var_CollAsgnReason_MARGIN_EXCESS_get, Swig_var_CollAsgnReason_MARGIN_EXCESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlPriceType_FINAL",Swig_var_SettlPriceType_FINAL_get, Swig_var_SettlPriceType_FINAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlPriceType_THEORETICAL",Swig_var_SettlPriceType_THEORETICAL_get, Swig_var_SettlPriceType_THEORETICAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DealingCapacity_RISKLESS_PRINCIPAL",Swig_var_DealingCapacity_RISKLESS_PRINCIPAL_get, Swig_var_DealingCapacity_RISKLESS_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DealingCapacity_PRINCIPAL",Swig_var_DealingCapacity_PRINCIPAL_get, Swig_var_DealingCapacity_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DealingCapacity_AGENT",Swig_var_DealingCapacity_AGENT_get, Swig_var_DealingCapacity_AGENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RateSourceType_SECONDARY",Swig_var_RateSourceType_SECONDARY_get, Swig_var_RateSourceType_SECONDARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RateSourceType_PRIMARY",Swig_var_RateSourceType_PRIMARY_get, Swig_var_RateSourceType_PRIMARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AggregatedBook_NO",Swig_var_AggregatedBook_NO_get, Swig_var_AggregatedBook_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AggregatedBook_YES",Swig_var_AggregatedBook_YES_get, Swig_var_AggregatedBook_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosQtyStatus_SUBMITTED",Swig_var_PosQtyStatus_SUBMITTED_get, Swig_var_PosQtyStatus_SUBMITTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosQtyStatus_REJECTED",Swig_var_PosQtyStatus_REJECTED_get, Swig_var_PosQtyStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosQtyStatus_ACCEPTED",Swig_var_PosQtyStatus_ACCEPTED_get, Swig_var_PosQtyStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradingSessionStatusRequest",Swig_var_MsgType_TradingSessionStatusRequest_get, Swig_var_MsgType_TradingSessionStatusRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ListStatus",Swig_var_MsgType_ListStatus_get, Swig_var_MsgType_ListStatus_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Email",Swig_var_MsgType_Email_get, Swig_var_MsgType_Email_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ListExecute",Swig_var_MsgType_ListExecute_get, Swig_var_MsgType_ListExecute_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Confirmation",Swig_var_MsgType_Confirmation_get, Swig_var_MsgType_Confirmation_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_NewOrderMultileg",Swig_var_MsgType_NewOrderMultileg_get, Swig_var_MsgType_NewOrderMultileg_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MarketDataIncrementalRefresh",Swig_var_MsgType_MarketDataIncrementalRefresh_get, Swig_var_MsgType_MarketDataIncrementalRefresh_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradeCaptureReport",Swig_var_MsgType_TradeCaptureReport_get, Swig_var_MsgType_TradeCaptureReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_RequestForPositionsAck",Swig_var_MsgType_RequestForPositionsAck_get, Swig_var_MsgType_RequestForPositionsAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_StreamAssignmentRequest",Swig_var_MsgType_StreamAssignmentRequest_get, Swig_var_MsgType_StreamAssignmentRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityListRequest",Swig_var_MsgType_SecurityListRequest_get, Swig_var_MsgType_SecurityListRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CollateralReport",Swig_var_MsgType_CollateralReport_get, Swig_var_MsgType_CollateralReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_PositionMaintenanceReport",Swig_var_MsgType_PositionMaintenanceReport_get, Swig_var_MsgType_PositionMaintenanceReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_PositionReport",Swig_var_MsgType_PositionReport_get, Swig_var_MsgType_PositionReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_StreamAssignmentReportACK",Swig_var_MsgType_StreamAssignmentReportACK_get, Swig_var_MsgType_StreamAssignmentReportACK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_UserRequest",Swig_var_MsgType_UserRequest_get, Swig_var_MsgType_UserRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_PositionMaintenanceRequest",Swig_var_MsgType_PositionMaintenanceRequest_get, Swig_var_MsgType_PositionMaintenanceRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_NetworkCounterpartySystemStatusResponse",Swig_var_MsgType_NetworkCounterpartySystemStatusResponse_get, Swig_var_MsgType_NetworkCounterpartySystemStatusResponse_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_NewOrderCross",Swig_var_MsgType_NewOrderCross_get, Swig_var_MsgType_NewOrderCross_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AdjustedPositionReport",Swig_var_MsgType_AdjustedPositionReport_get, Swig_var_MsgType_AdjustedPositionReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Logon",Swig_var_MsgType_Logon_get, Swig_var_MsgType_Logon_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_IOI",Swig_var_MsgType_IOI_get, Swig_var_MsgType_IOI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ListStrikePrice",Swig_var_MsgType_ListStrikePrice_get, Swig_var_MsgType_ListStrikePrice_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_BidRequest",Swig_var_MsgType_BidRequest_get, Swig_var_MsgType_BidRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradingSessionStatus",Swig_var_MsgType_TradingSessionStatus_get, Swig_var_MsgType_TradingSessionStatus_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_RegistrationInstructionsResponse",Swig_var_MsgType_RegistrationInstructionsResponse_get, Swig_var_MsgType_RegistrationInstructionsResponse_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Advertisement",Swig_var_MsgType_Advertisement_get, Swig_var_MsgType_Advertisement_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MassQuote",Swig_var_MsgType_MassQuote_get, Swig_var_MsgType_MassQuote_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Logout",Swig_var_MsgType_Logout_get, Swig_var_MsgType_Logout_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AllocationReport",Swig_var_MsgType_AllocationReport_get, Swig_var_MsgType_AllocationReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityDefinitionUpdateReport",Swig_var_MsgType_SecurityDefinitionUpdateReport_get, Swig_var_MsgType_SecurityDefinitionUpdateReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ListStatusRequest",Swig_var_MsgType_ListStatusRequest_get, Swig_var_MsgType_ListStatusRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_BusinessMessageReject",Swig_var_MsgType_BusinessMessageReject_get, Swig_var_MsgType_BusinessMessageReject_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ConfirmationAck",Swig_var_MsgType_ConfirmationAck_get, Swig_var_MsgType_ConfirmationAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_XMLnonFIX",Swig_var_MsgType_XMLnonFIX_get, Swig_var_MsgType_XMLnonFIX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TestRequest",Swig_var_MsgType_TestRequest_get, Swig_var_MsgType_TestRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityList",Swig_var_MsgType_SecurityList_get, Swig_var_MsgType_SecurityList_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ListCancelRequest",Swig_var_MsgType_ListCancelRequest_get, Swig_var_MsgType_ListCancelRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_News",Swig_var_MsgType_News_get, Swig_var_MsgType_News_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradingSessionListUpdateReport",Swig_var_MsgType_TradingSessionListUpdateReport_get, Swig_var_MsgType_TradingSessionListUpdateReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Heartbeat",Swig_var_MsgType_Heartbeat_get, Swig_var_MsgType_Heartbeat_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_QuoteAcknowledgement",Swig_var_MsgType_QuoteAcknowledgement_get, Swig_var_MsgType_QuoteAcknowledgement_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AllocationReportAck",Swig_var_MsgType_AllocationReportAck_get, Swig_var_MsgType_AllocationReportAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ConfirmationRequest",Swig_var_MsgType_ConfirmationRequest_get, Swig_var_MsgType_ConfirmationRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderMassActionReport",Swig_var_MsgType_OrderMassActionReport_get, Swig_var_MsgType_OrderMassActionReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CollateralInquiry",Swig_var_MsgType_CollateralInquiry_get, Swig_var_MsgType_CollateralInquiry_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityTypeRequest",Swig_var_MsgType_SecurityTypeRequest_get, Swig_var_MsgType_SecurityTypeRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_NewOrderList",Swig_var_MsgType_NewOrderList_get, Swig_var_MsgType_NewOrderList_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ExecutionAcknowledgement",Swig_var_MsgType_ExecutionAcknowledgement_get, Swig_var_MsgType_ExecutionAcknowledgement_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradingSessionListRequest",Swig_var_MsgType_TradingSessionListRequest_get, Swig_var_MsgType_TradingSessionListRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityTypes",Swig_var_MsgType_SecurityTypes_get, Swig_var_MsgType_SecurityTypes_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MarketDefinition",Swig_var_MsgType_MarketDefinition_get, Swig_var_MsgType_MarketDefinition_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SequenceReset",Swig_var_MsgType_SequenceReset_get, Swig_var_MsgType_SequenceReset_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CollateralResponse",Swig_var_MsgType_CollateralResponse_get, Swig_var_MsgType_CollateralResponse_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MassQuoteAcknowledgement",Swig_var_MsgType_MassQuoteAcknowledgement_get, Swig_var_MsgType_MassQuoteAcknowledgement_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_QuoteResponse",Swig_var_MsgType_QuoteResponse_get, Swig_var_MsgType_QuoteResponse_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_QuoteStatusRequest",Swig_var_MsgType_QuoteStatusRequest_get, Swig_var_MsgType_QuoteStatusRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_QuoteCancel",Swig_var_MsgType_QuoteCancel_get, Swig_var_MsgType_QuoteCancel_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ContraryIntentionReport",Swig_var_MsgType_ContraryIntentionReport_get, Swig_var_MsgType_ContraryIntentionReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CrossOrderCancelRequest",Swig_var_MsgType_CrossOrderCancelRequest_get, Swig_var_MsgType_CrossOrderCancelRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_NewOrderSingle",Swig_var_MsgType_NewOrderSingle_get, Swig_var_MsgType_NewOrderSingle_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_DerivativeSecurityListRequest",Swig_var_MsgType_DerivativeSecurityListRequest_get, Swig_var_MsgType_DerivativeSecurityListRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CollateralRequest",Swig_var_MsgType_CollateralRequest_get, Swig_var_MsgType_CollateralRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_UserNotification",Swig_var_MsgType_UserNotification_get, Swig_var_MsgType_UserNotification_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_UserResponse",Swig_var_MsgType_UserResponse_get, Swig_var_MsgType_UserResponse_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_DontKnowTrade",Swig_var_MsgType_DontKnowTrade_get, Swig_var_MsgType_DontKnowTrade_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradeCaptureReportAck",Swig_var_MsgType_TradeCaptureReportAck_get, Swig_var_MsgType_TradeCaptureReportAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ApplicationMessageRequest",Swig_var_MsgType_ApplicationMessageRequest_get, Swig_var_MsgType_ApplicationMessageRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MultilegOrderCancelReplace",Swig_var_MsgType_MultilegOrderCancelReplace_get, Swig_var_MsgType_MultilegOrderCancelReplace_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderCancelReject",Swig_var_MsgType_OrderCancelReject_get, Swig_var_MsgType_OrderCancelReject_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ExecutionReport",Swig_var_MsgType_ExecutionReport_get, Swig_var_MsgType_ExecutionReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_QuoteStatusReport",Swig_var_MsgType_QuoteStatusReport_get, Swig_var_MsgType_QuoteStatusReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ResendRequest",Swig_var_MsgType_ResendRequest_get, Swig_var_MsgType_ResendRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Quote",Swig_var_MsgType_Quote_get, Swig_var_MsgType_Quote_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SettlementInstructionRequest",Swig_var_MsgType_SettlementInstructionRequest_get, Swig_var_MsgType_SettlementInstructionRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityListUpdateReport",Swig_var_MsgType_SecurityListUpdateReport_get, Swig_var_MsgType_SecurityListUpdateReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AllocationInstructionAlert",Swig_var_MsgType_AllocationInstructionAlert_get, Swig_var_MsgType_AllocationInstructionAlert_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradeCaptureReportRequestAck",Swig_var_MsgType_TradeCaptureReportRequestAck_get, Swig_var_MsgType_TradeCaptureReportRequestAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AllocationInstruction",Swig_var_MsgType_AllocationInstruction_get, Swig_var_MsgType_AllocationInstruction_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Allocation",Swig_var_MsgType_Allocation_get, Swig_var_MsgType_Allocation_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_RegistrationInstructions",Swig_var_MsgType_RegistrationInstructions_get, Swig_var_MsgType_RegistrationInstructions_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityDefinition",Swig_var_MsgType_SecurityDefinition_get, Swig_var_MsgType_SecurityDefinition_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityDefinitionRequest",Swig_var_MsgType_SecurityDefinitionRequest_get, Swig_var_MsgType_SecurityDefinitionRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityStatus",Swig_var_MsgType_SecurityStatus_get, Swig_var_MsgType_SecurityStatus_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ApplicationMessageReport",Swig_var_MsgType_ApplicationMessageReport_get, Swig_var_MsgType_ApplicationMessageReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_DerivativeSecurityList",Swig_var_MsgType_DerivativeSecurityList_get, Swig_var_MsgType_DerivativeSecurityList_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_NetworkCounterpartySystemStatusRequest",Swig_var_MsgType_NetworkCounterpartySystemStatusRequest_get, Swig_var_MsgType_NetworkCounterpartySystemStatusRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MarketDefinitionRequest",Swig_var_MsgType_MarketDefinitionRequest_get, Swig_var_MsgType_MarketDefinitionRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_Reject",Swig_var_MsgType_Reject_get, Swig_var_MsgType_Reject_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_DerivativeSecurityListUpdateReport",Swig_var_MsgType_DerivativeSecurityListUpdateReport_get, Swig_var_MsgType_DerivativeSecurityListUpdateReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_QuoteRequestReject",Swig_var_MsgType_QuoteRequestReject_get, Swig_var_MsgType_QuoteRequestReject_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderMassStatusRequest",Swig_var_MsgType_OrderMassStatusRequest_get, Swig_var_MsgType_OrderMassStatusRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_ApplicationMessageRequestAck",Swig_var_MsgType_ApplicationMessageRequestAck_get, Swig_var_MsgType_ApplicationMessageRequestAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SecurityStatusRequest",Swig_var_MsgType_SecurityStatusRequest_get, Swig_var_MsgType_SecurityStatusRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MarketDefinitionUpdateReport",Swig_var_MsgType_MarketDefinitionUpdateReport_get, Swig_var_MsgType_MarketDefinitionUpdateReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CrossOrderCancelReplaceRequest",Swig_var_MsgType_CrossOrderCancelReplaceRequest_get, Swig_var_MsgType_CrossOrderCancelReplaceRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderMassCancelReport",Swig_var_MsgType_OrderMassCancelReport_get, Swig_var_MsgType_OrderMassCancelReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AssignmentReport",Swig_var_MsgType_AssignmentReport_get, Swig_var_MsgType_AssignmentReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_BidResponse",Swig_var_MsgType_BidResponse_get, Swig_var_MsgType_BidResponse_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_RequestForPositions",Swig_var_MsgType_RequestForPositions_get, Swig_var_MsgType_RequestForPositions_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SettlementObligationReport",Swig_var_MsgType_SettlementObligationReport_get, Swig_var_MsgType_SettlementObligationReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderMassCancelRequest",Swig_var_MsgType_OrderMassCancelRequest_get, Swig_var_MsgType_OrderMassCancelRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradingSessionList",Swig_var_MsgType_TradingSessionList_get, Swig_var_MsgType_TradingSessionList_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderStatusRequest",Swig_var_MsgType_OrderStatusRequest_get, Swig_var_MsgType_OrderStatusRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CollateralAssignment",Swig_var_MsgType_CollateralAssignment_get, Swig_var_MsgType_CollateralAssignment_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_StreamAssignmentReport",Swig_var_MsgType_StreamAssignmentReport_get, Swig_var_MsgType_StreamAssignmentReport_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderMassActionRequest",Swig_var_MsgType_OrderMassActionRequest_get, Swig_var_MsgType_OrderMassActionRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AllocationAck",Swig_var_MsgType_AllocationAck_get, Swig_var_MsgType_AllocationAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_QuoteRequest",Swig_var_MsgType_QuoteRequest_get, Swig_var_MsgType_QuoteRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_CollateralInquiryAck",Swig_var_MsgType_CollateralInquiryAck_get, Swig_var_MsgType_CollateralInquiryAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MarketDataSnapshotFullRefresh",Swig_var_MsgType_MarketDataSnapshotFullRefresh_get, Swig_var_MsgType_MarketDataSnapshotFullRefresh_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_SettlementInstructions",Swig_var_MsgType_SettlementInstructions_get, Swig_var_MsgType_SettlementInstructions_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderCancelReplaceRequest",Swig_var_MsgType_OrderCancelReplaceRequest_get, Swig_var_MsgType_OrderCancelReplaceRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_TradeCaptureReportRequest",Swig_var_MsgType_TradeCaptureReportRequest_get, Swig_var_MsgType_TradeCaptureReportRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_RFQRequest",Swig_var_MsgType_RFQRequest_get, Swig_var_MsgType_RFQRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_OrderCancelRequest",Swig_var_MsgType_OrderCancelRequest_get, Swig_var_MsgType_OrderCancelRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MultilegOrderCancelReplaceRequest",Swig_var_MsgType_MultilegOrderCancelReplaceRequest_get, Swig_var_MsgType_MultilegOrderCancelReplaceRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_AllocationInstructionAck",Swig_var_MsgType_AllocationInstructionAck_get, Swig_var_MsgType_AllocationInstructionAck_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MarketDataRequest",Swig_var_MsgType_MarketDataRequest_get, Swig_var_MsgType_MarketDataRequest_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgType_MarketDataRequestReject",Swig_var_MsgType_MarketDataRequestReject_get, Swig_var_MsgType_MarketDataRequestReject_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegReportingType_SINGLE_SECURITY",Swig_var_MultiLegReportingType_SINGLE_SECURITY_get, Swig_var_MultiLegReportingType_SINGLE_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegReportingType_MULTI_LEG_SECURITY",Swig_var_MultiLegReportingType_MULTI_LEG_SECURITY_get, Swig_var_MultiLegReportingType_MULTI_LEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY",Swig_var_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_get, Swig_var_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY",Swig_var_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_get, Swig_var_MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_EXCHANGE_SYMBOL",Swig_var_IDSource_EXCHANGE_SYMBOL_get, Swig_var_IDSource_EXCHANGE_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_RIC_CODE",Swig_var_IDSource_RIC_CODE_get, Swig_var_IDSource_RIC_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_ISO_CURRENCY_CODE",Swig_var_IDSource_ISO_CURRENCY_CODE_get, Swig_var_IDSource_ISO_CURRENCY_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_ISIN_NUMBER",Swig_var_IDSource_ISIN_NUMBER_get, Swig_var_IDSource_ISIN_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_SEDOL",Swig_var_IDSource_SEDOL_get, Swig_var_IDSource_SEDOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_ISO_COUNTRY_CODE",Swig_var_IDSource_ISO_COUNTRY_CODE_get, Swig_var_IDSource_ISO_COUNTRY_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_CONSOLIDATED_TAPE_ASSOCIATION",Swig_var_IDSource_CONSOLIDATED_TAPE_ASSOCIATION_get, Swig_var_IDSource_CONSOLIDATED_TAPE_ASSOCIATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_QUIK",Swig_var_IDSource_QUIK_get, Swig_var_IDSource_QUIK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IDSource_CUSIP",Swig_var_IDSource_CUSIP_get, Swig_var_IDSource_CUSIP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_NEW",Swig_var_OrdStatus_NEW_get, Swig_var_OrdStatus_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_CALCULATED",Swig_var_OrdStatus_CALCULATED_get, Swig_var_OrdStatus_CALCULATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_PENDING_CANCEL",Swig_var_OrdStatus_PENDING_CANCEL_get, Swig_var_OrdStatus_PENDING_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_PENDING_CANCEL_REPLACE",Swig_var_OrdStatus_PENDING_CANCEL_REPLACE_get, Swig_var_OrdStatus_PENDING_CANCEL_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_PENDING_NEW",Swig_var_OrdStatus_PENDING_NEW_get, Swig_var_OrdStatus_PENDING_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_STOPPED",Swig_var_OrdStatus_STOPPED_get, Swig_var_OrdStatus_STOPPED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_FILLED",Swig_var_OrdStatus_FILLED_get, Swig_var_OrdStatus_FILLED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_PENDING_REPLACE",Swig_var_OrdStatus_PENDING_REPLACE_get, Swig_var_OrdStatus_PENDING_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_CANCELED",Swig_var_OrdStatus_CANCELED_get, Swig_var_OrdStatus_CANCELED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_ACCEPTED_FOR_BIDDING",Swig_var_OrdStatus_ACCEPTED_FOR_BIDDING_get, Swig_var_OrdStatus_ACCEPTED_FOR_BIDDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_SUSPENDED",Swig_var_OrdStatus_SUSPENDED_get, Swig_var_OrdStatus_SUSPENDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_REJECTED",Swig_var_OrdStatus_REJECTED_get, Swig_var_OrdStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_PARTIALLY_FILLED",Swig_var_OrdStatus_PARTIALLY_FILLED_get, Swig_var_OrdStatus_PARTIALLY_FILLED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_EXPIRED",Swig_var_OrdStatus_EXPIRED_get, Swig_var_OrdStatus_EXPIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_REPLACED",Swig_var_OrdStatus_REPLACED_get, Swig_var_OrdStatus_REPLACED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdStatus_DONE_FOR_DAY",Swig_var_OrdStatus_DONE_FOR_DAY_get, Swig_var_OrdStatus_DONE_FOR_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustomerOrFirm_FIRM",Swig_var_CustomerOrFirm_FIRM_get, Swig_var_CustomerOrFirm_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustomerOrFirm_CUSTOMER",Swig_var_CustomerOrFirm_CUSTOMER_get, Swig_var_CustomerOrFirm_CUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdjustmentType_DELTA_MINUS",Swig_var_AdjustmentType_DELTA_MINUS_get, Swig_var_AdjustmentType_DELTA_MINUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdjustmentType_DELTA_PLUS",Swig_var_AdjustmentType_DELTA_PLUS_get, Swig_var_AdjustmentType_DELTA_PLUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdjustmentType_FINAL",Swig_var_AdjustmentType_FINAL_get, Swig_var_AdjustmentType_FINAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION",Swig_var_AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION_get, Swig_var_AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AsOfIndicator_TRUE",Swig_var_AsOfIndicator_TRUE_get, Swig_var_AsOfIndicator_TRUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AsOfIndicator_FALSE",Swig_var_AsOfIndicator_FALSE_get, Swig_var_AsOfIndicator_FALSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT",Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_MARKET",Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY",Swig_var_MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS",Swig_var_MassActionScope_ALL_ORDERS_get, Swig_var_MassActionScope_ALL_ORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_CFICODE",Swig_var_MassActionScope_ALL_ORDERS_FOR_A_CFICODE_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY",Swig_var_MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_SECURITY",Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION",Swig_var_MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_CANCEL_FOR_SECURITY_ISSUER",Swig_var_MassActionScope_CANCEL_FOR_SECURITY_ISSUER_get, Swig_var_MassActionScope_CANCEL_FOR_SECURITY_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP",Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_PRODUCT",Swig_var_MassActionScope_ALL_ORDERS_FOR_A_PRODUCT_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE",Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE_get, Swig_var_MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"VenueType_PIT",Swig_var_VenueType_PIT_get, Swig_var_VenueType_PIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"VenueType_EX_PIT",Swig_var_VenueType_EX_PIT_get, Swig_var_VenueType_EX_PIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"VenueType_ELECTRONIC",Swig_var_VenueType_ELECTRONIC_get, Swig_var_VenueType_ELECTRONIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionType_CANCEL_ORDERS",Swig_var_MassActionType_CANCEL_ORDERS_get, Swig_var_MassActionType_CANCEL_ORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionType_RELEASE_ORDERS_FROM_SUSPENSION",Swig_var_MassActionType_RELEASE_ORDERS_FROM_SUSPENSION_get, Swig_var_MassActionType_RELEASE_ORDERS_FROM_SUSPENSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionType_SUSPEND_ORDERS",Swig_var_MassActionType_SUSPEND_ORDERS_get, Swig_var_MassActionType_SUSPEND_ORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintResult_SUCCESSFUL_COMPLETION",Swig_var_PosMaintResult_SUCCESSFUL_COMPLETION_get, Swig_var_PosMaintResult_SUCCESSFUL_COMPLETION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintResult_OTHER",Swig_var_PosMaintResult_OTHER_get, Swig_var_PosMaintResult_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintResult_REJECTED",Swig_var_PosMaintResult_REJECTED_get, Swig_var_PosMaintResult_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIShares_MEDIUM",Swig_var_IOIShares_MEDIUM_get, Swig_var_IOIShares_MEDIUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIShares_LARGE",Swig_var_IOIShares_LARGE_get, Swig_var_IOIShares_LARGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIShares_SMALL",Swig_var_IOIShares_SMALL_get, Swig_var_IOIShares_SMALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegOffsetType_PRICE",Swig_var_PegOffsetType_PRICE_get, Swig_var_PegOffsetType_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegOffsetType_PRICE_TIER",Swig_var_PegOffsetType_PRICE_TIER_get, Swig_var_PegOffsetType_PRICE_TIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegOffsetType_TICKS",Swig_var_PegOffsetType_TICKS_get, Swig_var_PegOffsetType_TICKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegOffsetType_BASIS_POINTS",Swig_var_PegOffsetType_BASIS_POINTS_get, Swig_var_PegOffsetType_BASIS_POINTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT",Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY",Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED",Swig_var_MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED_get, Swig_var_MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP",Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY",Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY",Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE",Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE",Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION",Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET",Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE",Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_OTHER",Swig_var_MassCancelRejectReason_OTHER_get, Swig_var_MassCancelRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER",Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT",Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING",Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_get, Swig_var_MassCancelRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ResponseTransportType_INBAND",Swig_var_ResponseTransportType_INBAND_get, Swig_var_ResponseTransportType_INBAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ResponseTransportType_OUT_OF_BAND",Swig_var_ResponseTransportType_OUT_OF_BAND_get, Swig_var_ResponseTransportType_OUT_OF_BAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ResponseTransportType_INBAND_TRANSPORT_THE_REQUEST_WAS_SENT_OVER",Swig_var_ResponseTransportType_INBAND_TRANSPORT_THE_REQUEST_WAS_SENT_OVER_get, Swig_var_ResponseTransportType_INBAND_TRANSPORT_THE_REQUEST_WAS_SENT_OVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ResponseTransportType_OUT_OF_BAND_PRE_ARRANGED_OUT_OF_BAND_DELIVERY_MECHANISM",Swig_var_ResponseTransportType_OUT_OF_BAND_PRE_ARRANGED_OUT_OF_BAND_DELIVERY_MECHANISM_get, Swig_var_ResponseTransportType_OUT_OF_BAND_PRE_ARRANGED_OUT_OF_BAND_DELIVERY_MECHANISM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID",Swig_var_TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID_get, Swig_var_TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesStatusRejReason_OTHER",Swig_var_TradSesStatusRejReason_OTHER_get, Swig_var_TradSesStatusRejReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_EXECUTION_TIME",Swig_var_TrdRegTimestampType_EXECUTION_TIME_get, Swig_var_TrdRegTimestampType_EXECUTION_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_TIME_IN",Swig_var_TrdRegTimestampType_TIME_IN_get, Swig_var_TrdRegTimestampType_TIME_IN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_SUBMISSION_TO_CLEARING",Swig_var_TrdRegTimestampType_SUBMISSION_TO_CLEARING_get, Swig_var_TrdRegTimestampType_SUBMISSION_TO_CLEARING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_DESK_RECEIPT",Swig_var_TrdRegTimestampType_DESK_RECEIPT_get, Swig_var_TrdRegTimestampType_DESK_RECEIPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_BROKER_RECEIPT",Swig_var_TrdRegTimestampType_BROKER_RECEIPT_get, Swig_var_TrdRegTimestampType_BROKER_RECEIPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_BROKER_EXECUTION",Swig_var_TrdRegTimestampType_BROKER_EXECUTION_get, Swig_var_TrdRegTimestampType_BROKER_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRegTimestampType_TIME_OUT",Swig_var_TrdRegTimestampType_TIME_OUT_get, Swig_var_TrdRegTimestampType_TIME_OUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX50SP1",Swig_var_ApplVerID_FIX50SP1_get, Swig_var_ApplVerID_FIX50SP1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX27",Swig_var_ApplVerID_FIX27_get, Swig_var_ApplVerID_FIX27_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX50SP2",Swig_var_ApplVerID_FIX50SP2_get, Swig_var_ApplVerID_FIX50SP2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX50",Swig_var_ApplVerID_FIX50_get, Swig_var_ApplVerID_FIX50_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX40",Swig_var_ApplVerID_FIX40_get, Swig_var_ApplVerID_FIX40_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX41",Swig_var_ApplVerID_FIX41_get, Swig_var_ApplVerID_FIX41_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX30",Swig_var_ApplVerID_FIX30_get, Swig_var_ApplVerID_FIX30_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX42",Swig_var_ApplVerID_FIX42_get, Swig_var_ApplVerID_FIX42_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX43",Swig_var_ApplVerID_FIX43_get, Swig_var_ApplVerID_FIX43_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplVerID_FIX44",Swig_var_ApplVerID_FIX44_get, Swig_var_ApplVerID_FIX44_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HandlInst_MANUAL_ORDER_BEST_EXECUTION",Swig_var_HandlInst_MANUAL_ORDER_BEST_EXECUTION_get, Swig_var_HandlInst_MANUAL_ORDER_BEST_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION",Swig_var_HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION_get, Swig_var_HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK",Swig_var_HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK_get, Swig_var_HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionSubID_POST_TRADING",Swig_var_TradingSessionSubID_POST_TRADING_get, Swig_var_TradingSessionSubID_POST_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionSubID_INTRADAY_AUCTION",Swig_var_TradingSessionSubID_INTRADAY_AUCTION_get, Swig_var_TradingSessionSubID_INTRADAY_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionSubID_PRE_TRADING",Swig_var_TradingSessionSubID_PRE_TRADING_get, Swig_var_TradingSessionSubID_PRE_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionSubID_QUIESCENT",Swig_var_TradingSessionSubID_QUIESCENT_get, Swig_var_TradingSessionSubID_QUIESCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionSubID_3",Swig_var_TradingSessionSubID_3_get, Swig_var_TradingSessionSubID_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionSubID_OPENING_OR_OPENING_AUCTION",Swig_var_TradingSessionSubID_OPENING_OR_OPENING_AUCTION_get, Swig_var_TradingSessionSubID_OPENING_OR_OPENING_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION",Swig_var_TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_get, Swig_var_TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SWAP_VALUE_FACTOR",Swig_var_MDEntryType_SWAP_VALUE_FACTOR_get, Swig_var_MDEntryType_SWAP_VALUE_FACTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_COMPOSITE_UNDERLYING_PRICE",Swig_var_MDEntryType_COMPOSITE_UNDERLYING_PRICE_get, Swig_var_MDEntryType_COMPOSITE_UNDERLYING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SESSION_HIGH_BID",Swig_var_MDEntryType_SESSION_HIGH_BID_get, Swig_var_MDEntryType_SESSION_HIGH_BID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_OPEN_INTEREST",Swig_var_MDEntryType_OPEN_INTEREST_get, Swig_var_MDEntryType_OPEN_INTEREST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_CLOSING_PRICE",Swig_var_MDEntryType_CLOSING_PRICE_get, Swig_var_MDEntryType_CLOSING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_PRIOR_SETTLE_PRICE",Swig_var_MDEntryType_PRIOR_SETTLE_PRICE_get, Swig_var_MDEntryType_PRIOR_SETTLE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_TRADING_SESSION_VWAP_PRICE",Swig_var_MDEntryType_TRADING_SESSION_VWAP_PRICE_get, Swig_var_MDEntryType_TRADING_SESSION_VWAP_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_TRADING_SESSION_LOW_PRICE",Swig_var_MDEntryType_TRADING_SESSION_LOW_PRICE_get, Swig_var_MDEntryType_TRADING_SESSION_LOW_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SETTLE_HIGH_PRICE",Swig_var_MDEntryType_SETTLE_HIGH_PRICE_get, Swig_var_MDEntryType_SETTLE_HIGH_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_IMBALANCE",Swig_var_MDEntryType_IMBALANCE_get, Swig_var_MDEntryType_IMBALANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_FIXING_PRICE",Swig_var_MDEntryType_FIXING_PRICE_get, Swig_var_MDEntryType_FIXING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_CASH_RATE",Swig_var_MDEntryType_CASH_RATE_get, Swig_var_MDEntryType_CASH_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_OPENING_PRICE",Swig_var_MDEntryType_OPENING_PRICE_get, Swig_var_MDEntryType_OPENING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_TRADE",Swig_var_MDEntryType_TRADE_get, Swig_var_MDEntryType_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS",Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get, Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SIMULATED_SELL_PRICE",Swig_var_MDEntryType_SIMULATED_SELL_PRICE_get, Swig_var_MDEntryType_SIMULATED_SELL_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_EMPTY_BOOK",Swig_var_MDEntryType_EMPTY_BOOK_get, Swig_var_MDEntryType_EMPTY_BOOK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_AUCTION_CLEARING_PRICE",Swig_var_MDEntryType_AUCTION_CLEARING_PRICE_get, Swig_var_MDEntryType_AUCTION_CLEARING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_BID",Swig_var_MDEntryType_BID_get, Swig_var_MDEntryType_BID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_RECOVERY_RATE_FOR_SHORT",Swig_var_MDEntryType_RECOVERY_RATE_FOR_SHORT_get, Swig_var_MDEntryType_RECOVERY_RATE_FOR_SHORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SIMULATED_BUY_PRICE",Swig_var_MDEntryType_SIMULATED_BUY_PRICE_get, Swig_var_MDEntryType_SIMULATED_BUY_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_EARLY_PRICES",Swig_var_MDEntryType_EARLY_PRICES_get, Swig_var_MDEntryType_EARLY_PRICES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_TRADING_SESSION_HIGH_PRICE",Swig_var_MDEntryType_TRADING_SESSION_HIGH_PRICE_get, Swig_var_MDEntryType_TRADING_SESSION_HIGH_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_INDEX_VALUE",Swig_var_MDEntryType_INDEX_VALUE_get, Swig_var_MDEntryType_INDEX_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_RECOVERY_RATE_FOR_LONG",Swig_var_MDEntryType_RECOVERY_RATE_FOR_LONG_get, Swig_var_MDEntryType_RECOVERY_RATE_FOR_LONG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS",Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get, Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_MID_PRICE",Swig_var_MDEntryType_MID_PRICE_get, Swig_var_MDEntryType_MID_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_RECOVERY_RATE",Swig_var_MDEntryType_RECOVERY_RATE_get, Swig_var_MDEntryType_RECOVERY_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS",Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_get, Swig_var_MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS",Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_get, Swig_var_MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_MARGIN_RATE",Swig_var_MDEntryType_MARGIN_RATE_get, Swig_var_MDEntryType_MARGIN_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SETTLE_LOW_PRICE",Swig_var_MDEntryType_SETTLE_LOW_PRICE_get, Swig_var_MDEntryType_SETTLE_LOW_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SESSION_LOW_OFFER",Swig_var_MDEntryType_SESSION_LOW_OFFER_get, Swig_var_MDEntryType_SESSION_LOW_OFFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_TRADE_VOLUME",Swig_var_MDEntryType_TRADE_VOLUME_get, Swig_var_MDEntryType_TRADE_VOLUME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_SETTLEMENT_PRICE",Swig_var_MDEntryType_SETTLEMENT_PRICE_get, Swig_var_MDEntryType_SETTLEMENT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDEntryType_OFFER",Swig_var_MDEntryType_OFFER_get, Swig_var_MDEntryType_OFFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegMoveType_FLOATING",Swig_var_PegMoveType_FLOATING_get, Swig_var_PegMoveType_FLOATING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegMoveType_FIXED",Swig_var_PegMoveType_FIXED_get, Swig_var_PegMoveType_FIXED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AvgPxIndicator_LAST_TRADE_IN_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID",Swig_var_AvgPxIndicator_LAST_TRADE_IN_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get, Swig_var_AvgPxIndicator_LAST_TRADE_IN_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AvgPxIndicator_NO_AVERAGE_PRICING",Swig_var_AvgPxIndicator_NO_AVERAGE_PRICING_get, Swig_var_AvgPxIndicator_NO_AVERAGE_PRICING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID",Swig_var_AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get, Swig_var_AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID",Swig_var_AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_get, Swig_var_AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NO_WAIVER_AGREEMENT",Swig_var_CancellationRights_NO_WAIVER_AGREEMENT_get, Swig_var_CancellationRights_NO_WAIVER_AGREEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NO_M",Swig_var_CancellationRights_NO_M_get, Swig_var_CancellationRights_NO_M_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NO_N",Swig_var_CancellationRights_NO_N_get, Swig_var_CancellationRights_NO_N_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NO_INSTITUTIONAL",Swig_var_CancellationRights_NO_INSTITUTIONAL_get, Swig_var_CancellationRights_NO_INSTITUTIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_YES",Swig_var_CancellationRights_YES_get, Swig_var_CancellationRights_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NO_O",Swig_var_CancellationRights_NO_O_get, Swig_var_CancellationRights_NO_O_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CancellationRights_NO_EXECUTION_ONLY",Swig_var_CancellationRights_NO_EXECUTION_ONLY_get, Swig_var_CancellationRights_NO_EXECUTION_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_CREATION_PRICE",Swig_var_ExecPriceType_CREATION_PRICE_get, Swig_var_ExecPriceType_CREATION_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT",Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT_get, Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT",Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_get, Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT",Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT_get, Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT",Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT_get, Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT",Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT_get, Swig_var_ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_BID_PRICE",Swig_var_ExecPriceType_BID_PRICE_get, Swig_var_ExecPriceType_BID_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_SINGLE_PRICE",Swig_var_ExecPriceType_SINGLE_PRICE_get, Swig_var_ExecPriceType_SINGLE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT",Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_get, Swig_var_ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecPriceType_OFFER_PRICE",Swig_var_ExecPriceType_OFFER_PRICE_get, Swig_var_ExecPriceType_OFFER_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_PHONE_FOR_INSTRUCTIONS",Swig_var_AllocSettlInstType_PHONE_FOR_INSTRUCTIONS_get, Swig_var_AllocSettlInstType_PHONE_FOR_INSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_SSI_DB_IDS_PROVIDED",Swig_var_AllocSettlInstType_SSI_DB_IDS_PROVIDED_get, Swig_var_AllocSettlInstType_SSI_DB_IDS_PROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_FULL_DETAILS_PROVIDED",Swig_var_AllocSettlInstType_FULL_DETAILS_PROVIDED_get, Swig_var_AllocSettlInstType_FULL_DETAILS_PROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED",Swig_var_AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED_get, Swig_var_AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS",Swig_var_AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS_get, Swig_var_AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatsType_AVERAGE_PRICE",Swig_var_StatsType_AVERAGE_PRICE_get, Swig_var_StatsType_AVERAGE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatsType_HIGH",Swig_var_StatsType_HIGH_get, Swig_var_StatsType_HIGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatsType_EXCHANGE_LAST",Swig_var_StatsType_EXCHANGE_LAST_get, Swig_var_StatsType_EXCHANGE_LAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatsType_TURNOVER",Swig_var_StatsType_TURNOVER_get, Swig_var_StatsType_TURNOVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesMode_SIMULATED",Swig_var_TradSesMode_SIMULATED_get, Swig_var_TradSesMode_SIMULATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesMode_PRODUCTION",Swig_var_TradSesMode_PRODUCTION_get, Swig_var_TradSesMode_PRODUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesMode_TESTING",Swig_var_TradSesMode_TESTING_get, Swig_var_TradSesMode_TESTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstSource_INSTITUTIONS_INSTRUCTIONS",Swig_var_SettlInstSource_INSTITUTIONS_INSTRUCTIONS_get, Swig_var_SettlInstSource_INSTITUTIONS_INSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstSource_BROKERS_INSTRUCTIONS",Swig_var_SettlInstSource_BROKERS_INSTRUCTIONS_get, Swig_var_SettlInstSource_BROKERS_INSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstSource_INVESTOR",Swig_var_SettlInstSource_INVESTOR_get, Swig_var_SettlInstSource_INVESTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpType_DIFFERENCE",Swig_var_ExpType_DIFFERENCE_get, Swig_var_ExpType_DIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpType_FINAL_WILL_BE_EXERCISED",Swig_var_ExpType_FINAL_WILL_BE_EXERCISED_get, Swig_var_ExpType_FINAL_WILL_BE_EXERCISED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpType_NON_AUTO_EXERCISE",Swig_var_ExpType_NON_AUTO_EXERCISE_get, Swig_var_ExpType_NON_AUTO_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpType_CONTRARY_INTENTION",Swig_var_ExpType_CONTRARY_INTENTION_get, Swig_var_ExpType_CONTRARY_INTENTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpType_AUTO_EXERCISE",Swig_var_ExpType_AUTO_EXERCISE_get, Swig_var_ExpType_AUTO_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstTransType_REPLACE",Swig_var_SettlInstTransType_REPLACE_get, Swig_var_SettlInstTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstTransType_NEW",Swig_var_SettlInstTransType_NEW_get, Swig_var_SettlInstTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstTransType_RESTATE",Swig_var_SettlInstTransType_RESTATE_get, Swig_var_SettlInstTransType_RESTATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstTransType_CANCEL",Swig_var_SettlInstTransType_CANCEL_get, Swig_var_SettlInstTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALID_DESTINATION_REQUESTED",Swig_var_TradeRequestResult_INVALID_DESTINATION_REQUESTED_get, Swig_var_TradeRequestResult_INVALID_DESTINATION_REQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST",Swig_var_TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST_get, Swig_var_TradeRequestResult_UNAUTHORIZED_ROR_TRADE_CAPTURE_REPORT_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_UNAUTHORIZED_FOR_TRADE_CAPTURE_REPORT_REQUEST",Swig_var_TradeRequestResult_UNAUTHORIZED_FOR_TRADE_CAPTURE_REPORT_REQUEST_get, Swig_var_TradeRequestResult_UNAUTHORIZED_FOR_TRADE_CAPTURE_REPORT_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_SUCCESSFUL",Swig_var_TradeRequestResult_SUCCESSFUL_get, Swig_var_TradeRequestResult_SUCCESSFUL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_OTHER",Swig_var_TradeRequestResult_OTHER_get, Swig_var_TradeRequestResult_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT",Swig_var_TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT_get, Swig_var_TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALID_PARTIES",Swig_var_TradeRequestResult_INVALID_PARTIES_get, Swig_var_TradeRequestResult_INVALID_PARTIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED",Swig_var_TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED_get, Swig_var_TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_NOT_AUTHORIZED",Swig_var_TradeRequestResult_NOT_AUTHORIZED_get, Swig_var_TradeRequestResult_NOT_AUTHORIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED",Swig_var_TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED_get, Swig_var_TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED",Swig_var_TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED_get, Swig_var_TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TestMessageIndicator_NO",Swig_var_TestMessageIndicator_NO_get, Swig_var_TestMessageIndicator_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TestMessageIndicator_YES",Swig_var_TestMessageIndicator_YES_get, Swig_var_TestMessageIndicator_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE",Swig_var_ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE_get, Swig_var_ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE",Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE_get, Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN",Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN_get, Swig_var_ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS",Swig_var_AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS_get, Swig_var_AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocCancReplaceReason_OTHER",Swig_var_AllocCancReplaceReason_OTHER_get, Swig_var_AllocCancReplaceReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT",Swig_var_AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT_get, Swig_var_AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_DUPLICATE_CLORDID",Swig_var_CxlRejReason_DUPLICATE_CLORDID_get, Swig_var_CxlRejReason_DUPLICATE_CLORDID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE",Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_get, Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_DUPLICATE_CLORDID_RECEIVED",Swig_var_CxlRejReason_DUPLICATE_CLORDID_RECEIVED_get, Swig_var_CxlRejReason_DUPLICATE_CLORDID_RECEIVED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_UNKNOWN_ORDER",Swig_var_CxlRejReason_UNKNOWN_ORDER_get, Swig_var_CxlRejReason_UNKNOWN_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_TOO_LATE_TO_CANCEL",Swig_var_CxlRejReason_TOO_LATE_TO_CANCEL_get, Swig_var_CxlRejReason_TOO_LATE_TO_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_INVALID_PRICE_INCREMENT",Swig_var_CxlRejReason_INVALID_PRICE_INCREMENT_get, Swig_var_CxlRejReason_INVALID_PRICE_INCREMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_ORIGORDMODTIME",Swig_var_CxlRejReason_ORIGORDMODTIME_get, Swig_var_CxlRejReason_ORIGORDMODTIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_OTHER",Swig_var_CxlRejReason_OTHER_get, Swig_var_CxlRejReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_BROKER",Swig_var_CxlRejReason_BROKER_get, Swig_var_CxlRejReason_BROKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_BROKER_OPTION",Swig_var_CxlRejReason_BROKER_OPTION_get, Swig_var_CxlRejReason_BROKER_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST",Swig_var_CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST_get, Swig_var_CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS",Swig_var_CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS_get, Swig_var_CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND",Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_get, Swig_var_CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER",Swig_var_CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER_get, Swig_var_CxlRejReason_ORIGORDMODTIME_DID_NOT_MATCH_LAST_TRANSACTTIME_OF_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RespondentType_SPECIFIED_MARKET_PARTICIPANTS",Swig_var_RespondentType_SPECIFIED_MARKET_PARTICIPANTS_get, Swig_var_RespondentType_SPECIFIED_MARKET_PARTICIPANTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RespondentType_ALL_MARKET_MAKERS",Swig_var_RespondentType_ALL_MARKET_MAKERS_get, Swig_var_RespondentType_ALL_MARKET_MAKERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RespondentType_ALL_MARKET_PARTICIPANTS",Swig_var_RespondentType_ALL_MARKET_PARTICIPANTS_get, Swig_var_RespondentType_ALL_MARKET_PARTICIPANTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RespondentType_PRIMARY_MARKET_MAKER",Swig_var_RespondentType_PRIMARY_MARKET_MAKER_get, Swig_var_RespondentType_PRIMARY_MARKET_MAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_NO_MATCHING_ORDER",Swig_var_DKReason_NO_MATCHING_ORDER_get, Swig_var_DKReason_NO_MATCHING_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_PRICE_EXCEEDS_LIMIT",Swig_var_DKReason_PRICE_EXCEEDS_LIMIT_get, Swig_var_DKReason_PRICE_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_QUANTITY_EXCEEDS_ORDER",Swig_var_DKReason_QUANTITY_EXCEEDS_ORDER_get, Swig_var_DKReason_QUANTITY_EXCEEDS_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_UNKNOWN_SYMBOL",Swig_var_DKReason_UNKNOWN_SYMBOL_get, Swig_var_DKReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_OTHER",Swig_var_DKReason_OTHER_get, Swig_var_DKReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_WRONG_SIDE",Swig_var_DKReason_WRONG_SIDE_get, Swig_var_DKReason_WRONG_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DKReason_CALCULATION_DIFFERENCE",Swig_var_DKReason_CALCULATION_DIFFERENCE_get, Swig_var_DKReason_CALCULATION_DIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PositionEffect_DEFAULT",Swig_var_PositionEffect_DEFAULT_get, Swig_var_PositionEffect_DEFAULT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PositionEffect_CLOSE",Swig_var_PositionEffect_CLOSE_get, Swig_var_PositionEffect_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN",Swig_var_PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN_get, Swig_var_PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PositionEffect_OPEN",Swig_var_PositionEffect_OPEN_get, Swig_var_PositionEffect_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PositionEffect_FIFO",Swig_var_PositionEffect_FIFO_get, Swig_var_PositionEffect_FIFO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PositionEffect_ROLLED",Swig_var_PositionEffect_ROLLED_get, Swig_var_PositionEffect_ROLLED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerAction_ACTIVATE",Swig_var_TriggerAction_ACTIVATE_get, Swig_var_TriggerAction_ACTIVATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerAction_MODIFY",Swig_var_TriggerAction_MODIFY_get, Swig_var_TriggerAction_MODIFY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerAction_CANCEL",Swig_var_TriggerAction_CANCEL_get, Swig_var_TriggerAction_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_EXCLUDE_FROM_ALL_NETTING",Swig_var_ClearingInstruction_EXCLUDE_FROM_ALL_NETTING_get, Swig_var_ClearingInstruction_EXCLUDE_FROM_ALL_NETTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_AUTOMATIC_POSTING_MODE",Swig_var_ClearingInstruction_AUTOMATIC_POSTING_MODE_get, Swig_var_ClearingInstruction_AUTOMATIC_POSTING_MODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_MULTILATERAL_NETTING",Swig_var_ClearingInstruction_MULTILATERAL_NETTING_get, Swig_var_ClearingInstruction_MULTILATERAL_NETTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY",Swig_var_ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY_get, Swig_var_ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_AUTOMATIC_GIVE_UP_MODE",Swig_var_ClearingInstruction_AUTOMATIC_GIVE_UP_MODE_get, Swig_var_ClearingInstruction_AUTOMATIC_GIVE_UP_MODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_CUSTOMER_TRADE",Swig_var_ClearingInstruction_CUSTOMER_TRADE_get, Swig_var_ClearingInstruction_CUSTOMER_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_EX_CLEARING",Swig_var_ClearingInstruction_EX_CLEARING_get, Swig_var_ClearingInstruction_EX_CLEARING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY",Swig_var_ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY_get, Swig_var_ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_BILATERAL_NETTING_ONLY",Swig_var_ClearingInstruction_BILATERAL_NETTING_ONLY_get, Swig_var_ClearingInstruction_BILATERAL_NETTING_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_PROCESS_NORMALLY",Swig_var_ClearingInstruction_PROCESS_NORMALLY_get, Swig_var_ClearingInstruction_PROCESS_NORMALLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_SPECIAL_TRADE",Swig_var_ClearingInstruction_SPECIAL_TRADE_get, Swig_var_ClearingInstruction_SPECIAL_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_MANUAL_MODE",Swig_var_ClearingInstruction_MANUAL_MODE_get, Swig_var_ClearingInstruction_MANUAL_MODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR",Swig_var_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR_get, Swig_var_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE",Swig_var_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_get, Swig_var_ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ClearingInstruction_SELF_CLEARING",Swig_var_ClearingInstruction_SELF_CLEARING_get, Swig_var_ClearingInstruction_SELF_CLEARING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_SESSION_OPEN",Swig_var_OpenCloseSettlFlag_SESSION_OPEN_get, Swig_var_OpenCloseSettlFlag_SESSION_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_EXPECTED_ENTRY",Swig_var_OpenCloseSettlFlag_EXPECTED_ENTRY_get, Swig_var_OpenCloseSettlFlag_EXPECTED_ENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_DAILY_OPEN",Swig_var_OpenCloseSettlFlag_DAILY_OPEN_get, Swig_var_OpenCloseSettlFlag_DAILY_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE",Swig_var_OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE_get, Swig_var_OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY",Swig_var_OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_get, Swig_var_OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY",Swig_var_OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY_get, Swig_var_OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionMoveType_FLOATING",Swig_var_DiscretionMoveType_FLOATING_get, Swig_var_DiscretionMoveType_FLOATING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionMoveType_FIXED",Swig_var_DiscretionMoveType_FIXED_get, Swig_var_DiscretionMoveType_FIXED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateType_INCREMENTAL_REFRESH",Swig_var_MDUpdateType_INCREMENTAL_REFRESH_get, Swig_var_MDUpdateType_INCREMENTAL_REFRESH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateType_FULL_REFRESH",Swig_var_MDUpdateType_FULL_REFRESH_get, Swig_var_MDUpdateType_FULL_REFRESH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickDirection_MINUS_TICK",Swig_var_TickDirection_MINUS_TICK_get, Swig_var_TickDirection_MINUS_TICK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickDirection_ZERO_PLUS_TICK",Swig_var_TickDirection_ZERO_PLUS_TICK_get, Swig_var_TickDirection_ZERO_PLUS_TICK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickDirection_ZERO_MINUS_TICK",Swig_var_TickDirection_ZERO_MINUS_TICK_get, Swig_var_TickDirection_ZERO_MINUS_TICK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickDirection_PLUS_TICK",Swig_var_TickDirection_PLUS_TICK_get, Swig_var_TickDirection_PLUS_TICK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_MARK_TO_MARKET_YIELD",Swig_var_YieldType_MARK_TO_MARKET_YIELD_get, Swig_var_YieldType_MARK_TO_MARKET_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER",Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_get, Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_MATURITY",Swig_var_YieldType_YIELD_TO_MATURITY_get, Swig_var_YieldType_YIELD_TO_MATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_COMPOUND_YIELD_THE_YIELD_OF_CERTAIN_JAPANESE_BONDS_BASED_ON_ITS_PRICE_CERTAIN_JAPANESE_BONDS_HAVE_IRREGULAR_FIRST_OR_LAST_COUPONS_AND_THE_YIELD_IS_CALCULATED_COMPOUND_FOR_THESE_IRREGULAR_PERIODS",Swig_var_YieldType_COMPOUND_YIELD_THE_YIELD_OF_CERTAIN_JAPANESE_BONDS_BASED_ON_ITS_PRICE_CERTAIN_JAPANESE_BONDS_HAVE_IRREGULAR_FIRST_OR_LAST_COUPONS_AND_THE_YIELD_IS_CALCULATED_COMPOUND_FOR_THESE_IRREGULAR_PERIODS_get, Swig_var_YieldType_COMPOUND_YIELD_THE_YIELD_OF_CERTAIN_JAPANESE_BONDS_BASED_ON_ITS_PRICE_CERTAIN_JAPANESE_BONDS_HAVE_IRREGULAR_FIRST_OR_LAST_COUPONS_AND_THE_YIELD_IS_CALCULATED_COMPOUND_FOR_THESE_IRREGULAR_PERIODS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_PREVIOUS_CLOSE_YIELD",Swig_var_YieldType_PREVIOUS_CLOSE_YIELD_get, Swig_var_YieldType_PREVIOUS_CLOSE_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_AT_ISSUE",Swig_var_YieldType_YIELD_AT_ISSUE_get, Swig_var_YieldType_YIELD_AT_ISSUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_NEXT_REFUND",Swig_var_YieldType_YIELD_TO_NEXT_REFUND_get, Swig_var_YieldType_YIELD_TO_NEXT_REFUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_AFTER_TAX_YIELD",Swig_var_YieldType_AFTER_TAX_YIELD_get, Swig_var_YieldType_AFTER_TAX_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_GVNT_EQUIVALENT_YIELD",Swig_var_YieldType_GVNT_EQUIVALENT_YIELD_get, Swig_var_YieldType_GVNT_EQUIVALENT_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_SAME_AS_AVGLIFE_ABOVE",Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_SAME_AS_AVGLIFE_ABOVE_get, Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_SAME_AS_AVGLIFE_ABOVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_CHANGE_SINCE_CLOSE_THE_CHANGE_IN_THE_YIELD_SINCE_THE_PREVIOUS_DAYS_CLOSING_YIELD",Swig_var_YieldType_YIELD_CHANGE_SINCE_CLOSE_THE_CHANGE_IN_THE_YIELD_SINCE_THE_PREVIOUS_DAYS_CLOSING_YIELD_get, Swig_var_YieldType_YIELD_CHANGE_SINCE_CLOSE_THE_CHANGE_IN_THE_YIELD_SINCE_THE_PREVIOUS_DAYS_CLOSING_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CURRENT_YIELD_ANNUAL_INTEREST_ON_A_BOND_DIVIDED_BY_THE_MARKET_VALUE_THE_ACTUAL_INCOME_RATE_OF_RETURN_AS_OPPOSED_TO_THE_COUPON_RATE_EXPRESSED_AS_A_PERCENTAGE",Swig_var_YieldType_CURRENT_YIELD_ANNUAL_INTEREST_ON_A_BOND_DIVIDED_BY_THE_MARKET_VALUE_THE_ACTUAL_INCOME_RATE_OF_RETURN_AS_OPPOSED_TO_THE_COUPON_RATE_EXPRESSED_AS_A_PERCENTAGE_get, Swig_var_YieldType_CURRENT_YIELD_ANNUAL_INTEREST_ON_A_BOND_DIVIDED_BY_THE_MARKET_VALUE_THE_ACTUAL_INCOME_RATE_OF_RETURN_AS_OPPOSED_TO_THE_COUPON_RATE_EXPRESSED_AS_A_PERCENTAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE",Swig_var_YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE_get, Swig_var_YieldType_YIELD_TO_MATURITY_THE_YIELD_OF_A_BOND_TO_ITS_MATURITY_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSING_YIELD_MOST_RECENT_YEAR",Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_get, Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_NEXT_CALL",Swig_var_YieldType_YIELD_TO_NEXT_CALL_get, Swig_var_YieldType_YIELD_TO_NEXT_CALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_CHANGE_SINCE_CLOSE",Swig_var_YieldType_YIELD_CHANGE_SINCE_CLOSE_get, Swig_var_YieldType_YIELD_CHANGE_SINCE_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_PROCEEDS_YIELD",Swig_var_YieldType_PROCEEDS_YIELD_get, Swig_var_YieldType_PROCEEDS_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_TAX_EQUIVALENT_YIELD_THE_AFTER_TAX_YIELD_GROSSED_UP_BY_THE_MAXIMUM_FEDERAL_TAX_RATE_OF_396_FOR_COMPARISON_TO_TAXABLE_YIELDS",Swig_var_YieldType_TAX_EQUIVALENT_YIELD_THE_AFTER_TAX_YIELD_GROSSED_UP_BY_THE_MAXIMUM_FEDERAL_TAX_RATE_OF_396_FOR_COMPARISON_TO_TAXABLE_YIELDS_get, Swig_var_YieldType_TAX_EQUIVALENT_YIELD_THE_AFTER_TAX_YIELD_GROSSED_UP_BY_THE_MAXIMUM_FEDERAL_TAX_RATE_OF_396_FOR_COMPARISON_TO_TAXABLE_YIELDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_INVERSE_FLOATER_BOND_YIELD_INVERSE_FLOATER_SEMI_ANNUAL_BOND_EQUIVALENT_RATE",Swig_var_YieldType_INVERSE_FLOATER_BOND_YIELD_INVERSE_FLOATER_SEMI_ANNUAL_BOND_EQUIVALENT_RATE_get, Swig_var_YieldType_INVERSE_FLOATER_BOND_YIELD_INVERSE_FLOATER_SEMI_ANNUAL_BOND_EQUIVALENT_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CURRENT_YIELD",Swig_var_YieldType_CURRENT_YIELD_get, Swig_var_YieldType_CURRENT_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_BOOK_YIELD_THE_YIELD_OF_A_SECURITY_CALCULATED_BY_USING_ITS_BOOK_VALUE_INSTEAD_OF_THE_CURRENT_MARKET_PRICE_THIS_TERM_IS_TYPICALLY_USED_IN_THE_US_DOMESTIC_MARKET",Swig_var_YieldType_BOOK_YIELD_THE_YIELD_OF_A_SECURITY_CALCULATED_BY_USING_ITS_BOOK_VALUE_INSTEAD_OF_THE_CURRENT_MARKET_PRICE_THIS_TERM_IS_TYPICALLY_USED_IN_THE_US_DOMESTIC_MARKET_get, Swig_var_YieldType_BOOK_YIELD_THE_YIELD_OF_A_SECURITY_CALCULATED_BY_USING_ITS_BOOK_VALUE_INSTEAD_OF_THE_CURRENT_MARKET_PRICE_THIS_TERM_IS_TYPICALLY_USED_IN_THE_US_DOMESTIC_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_COMPOUND_YIELD",Swig_var_YieldType_COMPOUND_YIELD_get, Swig_var_YieldType_COMPOUND_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_NEXT_PUT_THE_YIELD_TO_THE_DATE_AT_WHICH_THE_BOND_HOLDER_CAN_NEXT_PUT_THE_BOND_TO_THE_ISSUER",Swig_var_YieldType_YIELD_TO_NEXT_PUT_THE_YIELD_TO_THE_DATE_AT_WHICH_THE_BOND_HOLDER_CAN_NEXT_PUT_THE_BOND_TO_THE_ISSUER_get, Swig_var_YieldType_YIELD_TO_NEXT_PUT_THE_YIELD_TO_THE_DATE_AT_WHICH_THE_BOND_HOLDER_CAN_NEXT_PUT_THE_BOND_TO_THE_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_GOVERNMENT_EQUIVALENT_YIELD_ASK_YIELD_BASED_ON_SEMI_ANNUAL_COUPONS_COMPOUNDING_IN_ALL_PERIODS_AND_ACTUAL_ACTUAL_CALENDAR",Swig_var_YieldType_GOVERNMENT_EQUIVALENT_YIELD_ASK_YIELD_BASED_ON_SEMI_ANNUAL_COUPONS_COMPOUNDING_IN_ALL_PERIODS_AND_ACTUAL_ACTUAL_CALENDAR_get, Swig_var_YieldType_GOVERNMENT_EQUIVALENT_YIELD_ASK_YIELD_BASED_ON_SEMI_ANNUAL_COUPONS_COMPOUNDING_IN_ALL_PERIODS_AND_ACTUAL_ACTUAL_CALENDAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_TENDER_DATE_THE_YIELD_ON_A_MUNICIPAL_BOND_TO_ITS_MANDATORY_TENDER_DATE",Swig_var_YieldType_YIELD_TO_TENDER_DATE_THE_YIELD_ON_A_MUNICIPAL_BOND_TO_ITS_MANDATORY_TENDER_DATE_get, Swig_var_YieldType_YIELD_TO_TENDER_DATE_THE_YIELD_ON_A_MUNICIPAL_BOND_TO_ITS_MANDATORY_TENDER_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_AVG_MATURITY",Swig_var_YieldType_YIELD_TO_AVG_MATURITY_get, Swig_var_YieldType_YIELD_TO_AVG_MATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO",Swig_var_YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_get, Swig_var_YieldType_OPEN_AVERAGE_YIELD_THE_AVERAGE_YIELD_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_TENDER_DATE",Swig_var_YieldType_YIELD_TO_TENDER_DATE_get, Swig_var_YieldType_YIELD_TO_TENDER_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_MONTHS_END",Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_MONTHS_END_get, Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_MONTHS_END_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_YEARS_END",Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_YEARS_END_get, Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_YEAR_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_YEARS_END_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_ANNUAL_YIELD",Swig_var_YieldType_ANNUAL_YIELD_get, Swig_var_YieldType_ANNUAL_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_WORST",Swig_var_YieldType_YIELD_TO_WORST_get, Swig_var_YieldType_YIELD_TO_WORST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_NEXT_PUT",Swig_var_YieldType_YIELD_TO_NEXT_PUT_get, Swig_var_YieldType_YIELD_TO_NEXT_PUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_BOOK_YIELD",Swig_var_YieldType_BOOK_YIELD_get, Swig_var_YieldType_BOOK_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_TRUE_YIELD",Swig_var_YieldType_TRUE_YIELD_get, Swig_var_YieldType_TRUE_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_TRUE_YIELD_THE_YIELD_CALCULATED_WITH_COUPON_DATES_MOVED_FROM_A_WEEKEND_OR_HOLIDAY_TO_THE_NEXT_VALID_SETTLEMENT_DATE",Swig_var_YieldType_TRUE_YIELD_THE_YIELD_CALCULATED_WITH_COUPON_DATES_MOVED_FROM_A_WEEKEND_OR_HOLIDAY_TO_THE_NEXT_VALID_SETTLEMENT_DATE_get, Swig_var_YieldType_TRUE_YIELD_THE_YIELD_CALCULATED_WITH_COUPON_DATES_MOVED_FROM_A_WEEKEND_OR_HOLIDAY_TO_THE_NEXT_VALID_SETTLEMENT_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_SEMI_ANNUAL_YIELD_THE_YIELD_OF_A_BOND_WHOSE_COUPON_PAYMENTS_ARE_REINVESTED_SEMI_ANNUALLY",Swig_var_YieldType_SEMI_ANNUAL_YIELD_THE_YIELD_OF_A_BOND_WHOSE_COUPON_PAYMENTS_ARE_REINVESTED_SEMI_ANNUALLY_get, Swig_var_YieldType_SEMI_ANNUAL_YIELD_THE_YIELD_OF_A_BOND_WHOSE_COUPON_PAYMENTS_ARE_REINVESTED_SEMI_ANNUALLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE",Swig_var_YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_get, Swig_var_YieldType_CLOSING_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_TAX_EQUIVALENT_YIELD",Swig_var_YieldType_TAX_EQUIVALENT_YIELD_get, Swig_var_YieldType_TAX_EQUIVALENT_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_PREVIOUS_CLOSE_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_1_DAY_AGO",Swig_var_YieldType_PREVIOUS_CLOSE_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_1_DAY_AGO_get, Swig_var_YieldType_PREVIOUS_CLOSE_YIELD_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_1_DAY_AGO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_VALUE_OF_1_32_THE_AMOUNT_THAT_THE_YIELD_WILL_CHANGE_FOR_A_1_32ND_CHANGE_IN_PRICE",Swig_var_YieldType_YIELD_VALUE_OF_1_32_THE_AMOUNT_THAT_THE_YIELD_WILL_CHANGE_FOR_A_1_32ND_CHANGE_IN_PRICE_get, Swig_var_YieldType_YIELD_VALUE_OF_1_32_THE_AMOUNT_THAT_THE_YIELD_WILL_CHANGE_FOR_A_1_32ND_CHANGE_IN_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_TRUE_GROSS_YIELD",Swig_var_YieldType_TRUE_GROSS_YIELD_get, Swig_var_YieldType_TRUE_GROSS_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_LONGEST_AVERAGE",Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_get, Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_INVERSE_FLOATER_BOND_YIELD",Swig_var_YieldType_INVERSE_FLOATER_BOND_YIELD_get, Swig_var_YieldType_INVERSE_FLOATER_BOND_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSING_YIELD_MOST_RECENT_MONTH",Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_get, Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_MONTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_AVERAGE_LIFE_THE_YIELD_ASSUMING_THAT_ALL_SINKS",Swig_var_YieldType_YIELD_TO_AVERAGE_LIFE_THE_YIELD_ASSUMING_THAT_ALL_SINKS_get, Swig_var_YieldType_YIELD_TO_AVERAGE_LIFE_THE_YIELD_ASSUMING_THAT_ALL_SINKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_QUARTERS_END",Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_QUARTERS_END_get, Swig_var_YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER_THE_YIELD_OF_A_BOND_BASED_ON_THE_CLOSING_PRICE_AS_OF_THE_MOST_RECENT_QUARTERS_END_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_SHORTEST_AVERAGE",Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_get, Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_OPEN_AVERAGE_YIELD",Swig_var_YieldType_OPEN_AVERAGE_YIELD_get, Swig_var_YieldType_OPEN_AVERAGE_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_TRUE_GROSS_YIELD_YIELD_CALCULATED_USING_THE_PRICE_INCLUDING_ACCRUED_INTEREST_WHERE_COUPON_DATES_ARE_MOVED_FROM_HOLIDAYS_AND_WEEKENDS_TO_THE_NEXT_TRADING_DAY",Swig_var_YieldType_TRUE_GROSS_YIELD_YIELD_CALCULATED_USING_THE_PRICE_INCLUDING_ACCRUED_INTEREST_WHERE_COUPON_DATES_ARE_MOVED_FROM_HOLIDAYS_AND_WEEKENDS_TO_THE_NEXT_TRADING_DAY_get, Swig_var_YieldType_TRUE_GROSS_YIELD_YIELD_CALCULATED_USING_THE_PRICE_INCLUDING_ACCRUED_INTEREST_WHERE_COUPON_DATES_ARE_MOVED_FROM_HOLIDAYS_AND_WEEKENDS_TO_THE_NEXT_TRADING_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_PROCEEDS_YIELD_THE_CD_EQUIVALENT_YIELD_WHEN_THE_REMAINING_TIME_TO_MATURITY_IS_LESS_THAN_TWO_YEARS",Swig_var_YieldType_PROCEEDS_YIELD_THE_CD_EQUIVALENT_YIELD_WHEN_THE_REMAINING_TIME_TO_MATURITY_IS_LESS_THAN_TWO_YEARS_get, Swig_var_YieldType_PROCEEDS_YIELD_THE_CD_EQUIVALENT_YIELD_WHEN_THE_REMAINING_TIME_TO_MATURITY_IS_LESS_THAN_TWO_YEARS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_WITH_INFLATION_ASSUMPTION",Swig_var_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_get, Swig_var_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_THE_YIELD_ASSUMING_ONLY_MANDATORY_SINKS_ARE_TAKEN_THIS_RESULTS_IN_A_LOWER_PAYDOWN_OF_DEBT_THE_YIELD_IS_THEN_CALCULATED_TO_THE_FINAL_PAYMENT_DATE",Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_THE_YIELD_ASSUMING_ONLY_MANDATORY_SINKS_ARE_TAKEN_THIS_RESULTS_IN_A_LOWER_PAYDOWN_OF_DEBT_THE_YIELD_IS_THEN_CALCULATED_TO_THE_FINAL_PAYMENT_DATE_get, Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_THE_YIELD_ASSUMING_ONLY_MANDATORY_SINKS_ARE_TAKEN_THIS_RESULTS_IN_A_LOWER_PAYDOWN_OF_DEBT_THE_YIELD_IS_THEN_CALCULATED_TO_THE_FINAL_PAYMENT_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_MARK_TO_MARKET_YIELD_AN_ADJUSTMENT_IN_THE_VALUATION_OF_A_SECURITIES_PORTFOLIO_TO_REFLECT_THE_CURRENT_MARKET_VALUES_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO",Swig_var_YieldType_MARK_TO_MARKET_YIELD_AN_ADJUSTMENT_IN_THE_VALUATION_OF_A_SECURITIES_PORTFOLIO_TO_REFLECT_THE_CURRENT_MARKET_VALUES_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_get, Swig_var_YieldType_MARK_TO_MARKET_YIELD_AN_ADJUSTMENT_IN_THE_VALUATION_OF_A_SECURITIES_PORTFOLIO_TO_REFLECT_THE_CURRENT_MARKET_VALUES_OF_THE_RESPECTIVE_SECURITIES_IN_THE_PORTFOLIO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_AVERAGE_MATURITY",Swig_var_YieldType_YIELD_TO_AVERAGE_MATURITY_get, Swig_var_YieldType_YIELD_TO_AVERAGE_MATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_WORST_CONVENTION_THE_LOWEST_YIELD_TO_ALL_POSSIBLE_REDEMPTION_DATE_SCENARIOS",Swig_var_YieldType_YIELD_TO_WORST_CONVENTION_THE_LOWEST_YIELD_TO_ALL_POSSIBLE_REDEMPTION_DATE_SCENARIOS_get, Swig_var_YieldType_YIELD_TO_WORST_CONVENTION_THE_LOWEST_YIELD_TO_ALL_POSSIBLE_REDEMPTION_DATE_SCENARIOS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_NEXT_CALL_THE_YIELD_OF_A_BOND_TO_THE_NEXT_POSSIBLE_CALL_DATE",Swig_var_YieldType_YIELD_TO_NEXT_CALL_THE_YIELD_OF_A_BOND_TO_THE_NEXT_POSSIBLE_CALL_DATE_get, Swig_var_YieldType_YIELD_TO_NEXT_CALL_THE_YIELD_OF_A_BOND_TO_THE_NEXT_POSSIBLE_CALL_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_SIMPLE_YIELD",Swig_var_YieldType_SIMPLE_YIELD_get, Swig_var_YieldType_SIMPLE_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_ANNUAL_YIELD_THE_ANNUAL_INTEREST_OR_DIVIDEND_INCOME_AN_INVESTMENT_EARNS_EXPRESSED_AS_A_PERCENTAGE_OF_THE_INVESTMENTS_TOTAL_VALUE",Swig_var_YieldType_ANNUAL_YIELD_THE_ANNUAL_INTEREST_OR_DIVIDEND_INCOME_AN_INVESTMENT_EARNS_EXPRESSED_AS_A_PERCENTAGE_OF_THE_INVESTMENTS_TOTAL_VALUE_get, Swig_var_YieldType_ANNUAL_YIELD_THE_ANNUAL_INTEREST_OR_DIVIDEND_INCOME_AN_INVESTMENT_EARNS_EXPRESSED_AS_A_PERCENTAGE_OF_THE_INVESTMENTS_TOTAL_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_SEMI_ANNUAL_YIELD",Swig_var_YieldType_SEMI_ANNUAL_YIELD_get, Swig_var_YieldType_SEMI_ANNUAL_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_MOST_RECENT_CLOSING_YIELD",Swig_var_YieldType_MOST_RECENT_CLOSING_YIELD_get, Swig_var_YieldType_MOST_RECENT_CLOSING_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_GOVERNMENT_EQUIVALENT_YIELD",Swig_var_YieldType_GOVERNMENT_EQUIVALENT_YIELD_get, Swig_var_YieldType_GOVERNMENT_EQUIVALENT_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE",Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_get, Swig_var_YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_CLOSING_YIELD",Swig_var_YieldType_CLOSING_YIELD_get, Swig_var_YieldType_CLOSING_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_WITH_INFLATION_ASSUMPTION_BASED_ON_PRICE_THE_RETURN_AN_INVESTOR_WOULD_REQUIRE_ON_A_NORMAL_BOND_THAT_WOULD_MAKE_THE_REAL_RETURN_EQUAL_TO_THAT_OF_THE_INFLATION_INDEXED_BOND_ASSUMING_A_CONSTANT_INFLATION_RATE",Swig_var_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_BASED_ON_PRICE_THE_RETURN_AN_INVESTOR_WOULD_REQUIRE_ON_A_NORMAL_BOND_THAT_WOULD_MAKE_THE_REAL_RETURN_EQUAL_TO_THAT_OF_THE_INFLATION_INDEXED_BOND_ASSUMING_A_CONSTANT_INFLATION_RATE_get, Swig_var_YieldType_YIELD_WITH_INFLATION_ASSUMPTION_BASED_ON_PRICE_THE_RETURN_AN_INVESTOR_WOULD_REQUIRE_ON_A_NORMAL_BOND_THAT_WOULD_MAKE_THE_REAL_RETURN_EQUAL_TO_THAT_OF_THE_INFLATION_INDEXED_BOND_ASSUMING_A_CONSTANT_INFLATION_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_VALUE_OF_1_32",Swig_var_YieldType_YIELD_VALUE_OF_1_32_get, Swig_var_YieldType_YIELD_VALUE_OF_1_32_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE",Swig_var_YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE_get, Swig_var_YieldType_MOST_RECENT_CLOSING_YIELD_THE_LAST_AVAILABLE_YIELD_STORED_IN_HISTORY_COMPUTED_USING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE",Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_get, Swig_var_YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS",Swig_var_YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS_get, Swig_var_YieldType_SIMPLE_YIELD_THE_YIELD_OF_A_BOND_ASSUMING_NO_REINVESTMENT_OF_COUPON_PAYMENTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"YieldType_YIELD_TO_AVERAGE_MATURITY_THE_YIELD_ACHIEVED_BY_SUBSTITUTING_A_BONDS_AVERAGE_MATURITY_FOR_THE_ISSUES_FINAL_MATURITY_DATE",Swig_var_YieldType_YIELD_TO_AVERAGE_MATURITY_THE_YIELD_ACHIEVED_BY_SUBSTITUTING_A_BONDS_AVERAGE_MATURITY_FOR_THE_ISSUES_FINAL_MATURITY_DATE_get, Swig_var_YieldType_YIELD_TO_AVERAGE_MATURITY_THE_YIELD_ACHIEVED_BY_SUBSTITUTING_A_BONDS_AVERAGE_MATURITY_FOR_THE_ISSUES_FINAL_MATURITY_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegScope_NATIONAL_XXCLUDING_LOCAL",Swig_var_PegScope_NATIONAL_XXCLUDING_LOCAL_get, Swig_var_PegScope_NATIONAL_XXCLUDING_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegScope_NATIONAL_EXCLUDING_LOCAL",Swig_var_PegScope_NATIONAL_EXCLUDING_LOCAL_get, Swig_var_PegScope_NATIONAL_EXCLUDING_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegScope_LOCAL",Swig_var_PegScope_LOCAL_get, Swig_var_PegScope_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegScope_GLOBAL",Swig_var_PegScope_GLOBAL_get, Swig_var_PegScope_GLOBAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegScope_NATIONAL",Swig_var_PegScope_NATIONAL_get, Swig_var_PegScope_NATIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlDeliveryType_TRI_PARTY",Swig_var_SettlDeliveryType_TRI_PARTY_get, Swig_var_SettlDeliveryType_TRI_PARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlDeliveryType_HOLD_IN_CUSTODY",Swig_var_SettlDeliveryType_HOLD_IN_CUSTODY_get, Swig_var_SettlDeliveryType_HOLD_IN_CUSTODY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlDeliveryType_FREE",Swig_var_SettlDeliveryType_FREE_get, Swig_var_SettlDeliveryType_FREE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlDeliveryType_VERSUS_PAYMENT_DELIVER",Swig_var_SettlDeliveryType_VERSUS_PAYMENT_DELIVER_get, Swig_var_SettlDeliveryType_VERSUS_PAYMENT_DELIVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlDeliveryType_FREE_DELIVER",Swig_var_SettlDeliveryType_FREE_DELIVER_get, Swig_var_SettlDeliveryType_FREE_DELIVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlDeliveryType_VERSUS_PAYMENT",Swig_var_SettlDeliveryType_VERSUS_PAYMENT_get, Swig_var_SettlDeliveryType_VERSUS_PAYMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionLimitType_STRICT",Swig_var_DiscretionLimitType_STRICT_get, Swig_var_DiscretionLimitType_STRICT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionLimitType_OR_BETTER",Swig_var_DiscretionLimitType_OR_BETTER_get, Swig_var_DiscretionLimitType_OR_BETTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionLimitType_OR_WORSE",Swig_var_DiscretionLimitType_OR_WORSE_get, Swig_var_DiscretionLimitType_OR_WORSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT",Swig_var_DiscretionLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT_get, Swig_var_DiscretionLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionLimitType_OR_WORSE_FOR_A_BUY_THE_DISCRETION_PRICE_IS_A_MINIMUM_AND_FOR_A_SELL_THE_DISCRETION_PRICE_IS_A_MAXIMUM",Swig_var_DiscretionLimitType_OR_WORSE_FOR_A_BUY_THE_DISCRETION_PRICE_IS_A_MINIMUM_AND_FOR_A_SELL_THE_DISCRETION_PRICE_IS_A_MAXIMUM_get, Swig_var_DiscretionLimitType_OR_WORSE_FOR_A_BUY_THE_DISCRETION_PRICE_IS_A_MINIMUM_AND_FOR_A_SELL_THE_DISCRETION_PRICE_IS_A_MAXIMUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExerciseMethod_AUTOMATIC",Swig_var_ExerciseMethod_AUTOMATIC_get, Swig_var_ExerciseMethod_AUTOMATIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExerciseMethod_MANUAL",Swig_var_ExerciseMethod_MANUAL_get, Swig_var_ExerciseMethod_MANUAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"WorkingIndicator_NO",Swig_var_WorkingIndicator_NO_get, Swig_var_WorkingIndicator_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"WorkingIndicator_YES",Swig_var_WorkingIndicator_YES_get, Swig_var_WorkingIndicator_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideMultiLegReportingType_MULTILEG_SECURITY",Swig_var_SideMultiLegReportingType_MULTILEG_SECURITY_get, Swig_var_SideMultiLegReportingType_MULTILEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideMultiLegReportingType_SINGLE_SECURITY",Swig_var_SideMultiLegReportingType_SINGLE_SECURITY_get, Swig_var_SideMultiLegReportingType_SINGLE_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideMultiLegReportingType_MULTI_LEG_SECURITY",Swig_var_SideMultiLegReportingType_MULTI_LEG_SECURITY_get, Swig_var_SideMultiLegReportingType_MULTI_LEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY",Swig_var_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_get, Swig_var_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY",Swig_var_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_get, Swig_var_SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS",Swig_var_ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS_get, Swig_var_ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmRejReason_OTHER",Swig_var_ConfirmRejReason_OTHER_get, Swig_var_ConfirmRejReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmRejReason_MISMATCHED_ACCOUNT",Swig_var_ConfirmRejReason_MISMATCHED_ACCOUNT_get, Swig_var_ConfirmRejReason_MISMATCHED_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidRequestTransType_NEW",Swig_var_BidRequestTransType_NEW_get, Swig_var_BidRequestTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidRequestTransType_NO",Swig_var_BidRequestTransType_NO_get, Swig_var_BidRequestTransType_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidRequestTransType_CANCEL",Swig_var_BidRequestTransType_CANCEL_get, Swig_var_BidRequestTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY",Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP",Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY",Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE",Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE",Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY",Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION",Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT",Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET",Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED",Swig_var_MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED_get, Swig_var_MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_OTHER",Swig_var_MassActionRejectReason_OTHER_get, Swig_var_MassActionRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER",Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT",Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT_get, Swig_var_MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollApplType_GENERAL",Swig_var_CollApplType_GENERAL_get, Swig_var_CollApplType_GENERAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollApplType_SPECIFIC_DEPOSIT",Swig_var_CollApplType_SPECIFIC_DEPOSIT_get, Swig_var_CollApplType_SPECIFIC_DEPOSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmType_CONFIRMATION",Swig_var_ConfirmType_CONFIRMATION_get, Swig_var_ConfirmType_CONFIRMATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmType_CONFIRMATION_REQUEST_REJECTED",Swig_var_ConfirmType_CONFIRMATION_REQUEST_REJECTED_get, Swig_var_ConfirmType_CONFIRMATION_REQUEST_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmType_STATUS",Swig_var_ConfirmType_STATUS_get, Swig_var_ConfirmType_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDQuoteType_INDICATIVE",Swig_var_MDQuoteType_INDICATIVE_get, Swig_var_MDQuoteType_INDICATIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDQuoteType_RESTRICTED_TRADEABLE",Swig_var_MDQuoteType_RESTRICTED_TRADEABLE_get, Swig_var_MDQuoteType_RESTRICTED_TRADEABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDQuoteType_INDICATIVE_AND_TRADEABLE",Swig_var_MDQuoteType_INDICATIVE_AND_TRADEABLE_get, Swig_var_MDQuoteType_INDICATIVE_AND_TRADEABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDQuoteType_TRADEABLE",Swig_var_MDQuoteType_TRADEABLE_get, Swig_var_MDQuoteType_TRADEABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDQuoteType_COUNTER",Swig_var_MDQuoteType_COUNTER_get, Swig_var_MDQuoteType_COUNTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QtyType_CONTRACTS",Swig_var_QtyType_CONTRACTS_get, Swig_var_QtyType_CONTRACTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT",Swig_var_QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT_get, Swig_var_QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QtyType_UNITS",Swig_var_QtyType_UNITS_get, Swig_var_QtyType_UNITS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_END_TRADE",Swig_var_QuoteRespType_END_TRADE_get, Swig_var_QuoteRespType_END_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_COVER",Swig_var_QuoteRespType_COVER_get, Swig_var_QuoteRespType_COVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_HIT_LIFT",Swig_var_QuoteRespType_HIT_LIFT_get, Swig_var_QuoteRespType_HIT_LIFT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_DONE_AWAY",Swig_var_QuoteRespType_DONE_AWAY_get, Swig_var_QuoteRespType_DONE_AWAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_TIMED_OUT",Swig_var_QuoteRespType_TIMED_OUT_get, Swig_var_QuoteRespType_TIMED_OUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_PASS",Swig_var_QuoteRespType_PASS_get, Swig_var_QuoteRespType_PASS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_EXPIRED",Swig_var_QuoteRespType_EXPIRED_get, Swig_var_QuoteRespType_EXPIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRespType_COUNTER",Swig_var_QuoteRespType_COUNTER_get, Swig_var_QuoteRespType_COUNTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOINaturalFlag_NO",Swig_var_IOINaturalFlag_NO_get, Swig_var_IOINaturalFlag_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOINaturalFlag_YES",Swig_var_IOINaturalFlag_YES_get, Swig_var_IOINaturalFlag_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligSource_INSTRUCTIONS_OF_BROKER",Swig_var_SettlObligSource_INSTRUCTIONS_OF_BROKER_get, Swig_var_SettlObligSource_INSTRUCTIONS_OF_BROKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligSource_INVESTOR",Swig_var_SettlObligSource_INVESTOR_get, Swig_var_SettlObligSource_INVESTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION",Swig_var_SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION_get, Swig_var_SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_ON_HOURS_TRADE",Swig_var_TrdSubType_ON_HOURS_TRADE_get, Swig_var_TrdSubType_ON_HOURS_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_INTERIM_PROTECTED_TRADE",Swig_var_TrdSubType_INTERIM_PROTECTED_TRADE_get, Swig_var_TrdSubType_INTERIM_PROTECTED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_K",Swig_var_TrdSubType_K_get, Swig_var_TrdSubType_K_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_LC",Swig_var_TrdSubType_LC_get, Swig_var_TrdSubType_LC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_WN",Swig_var_TrdSubType_WN_get, Swig_var_TrdSubType_WN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_CONVERTED_SWAP",Swig_var_TrdSubType_CONVERTED_SWAP_get, Swig_var_TrdSubType_CONVERTED_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_B",Swig_var_TrdSubType_B_get, Swig_var_TrdSubType_B_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_M",Swig_var_TrdSubType_M_get, Swig_var_TrdSubType_M_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_RT",Swig_var_TrdSubType_RT_get, Swig_var_TrdSubType_RT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_ONSET_DUE_TO_AN_ALLOCATION",Swig_var_TrdSubType_ONSET_DUE_TO_AN_ALLOCATION_get, Swig_var_TrdSubType_ONSET_DUE_TO_AN_ALLOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_CMTA",Swig_var_TrdSubType_CMTA_get, Swig_var_TrdSubType_CMTA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT",Swig_var_TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT_get, Swig_var_TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_DIFFERENTIAL_SPREAD",Swig_var_TrdSubType_DIFFERENTIAL_SPREAD_get, Swig_var_TrdSubType_DIFFERENTIAL_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_TRANSACTION_FROM_EXERCISE",Swig_var_TrdSubType_TRANSACTION_FROM_EXERCISE_get, Swig_var_TrdSubType_TRANSACTION_FROM_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_TRANSACTION_FROM_ASSIGNMENT",Swig_var_TrdSubType_TRANSACTION_FROM_ASSIGNMENT_get, Swig_var_TrdSubType_TRANSACTION_FROM_ASSIGNMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_N",Swig_var_TrdSubType_N_get, Swig_var_TrdSubType_N_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT",Swig_var_TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_get, Swig_var_TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_NR",Swig_var_TrdSubType_NR_get, Swig_var_TrdSubType_NR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_SW",Swig_var_TrdSubType_SW_get, Swig_var_TrdSubType_SW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_OTC_QUOTE",Swig_var_TrdSubType_OTC_QUOTE_get, Swig_var_TrdSubType_OTC_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_ADVISORY_FOR_CONTRA_SIDE",Swig_var_TrdSubType_ADVISORY_FOR_CONTRA_SIDE_get, Swig_var_TrdSubType_ADVISORY_FOR_CONTRA_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION",Swig_var_TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION_get, Swig_var_TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_P",Swig_var_TrdSubType_P_get, Swig_var_TrdSubType_P_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_CROSSED_TRADE",Swig_var_TrdSubType_CROSSED_TRADE_get, Swig_var_TrdSubType_CROSSED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_PA",Swig_var_TrdSubType_PA_get, Swig_var_TrdSubType_PA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT",Swig_var_TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT_get, Swig_var_TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_R",Swig_var_TrdSubType_R_get, Swig_var_TrdSubType_R_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_RO",Swig_var_TrdSubType_RO_get, Swig_var_TrdSubType_RO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_WT",Swig_var_TrdSubType_WT_get, Swig_var_TrdSubType_WT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_OFF_HOURS_TRADE",Swig_var_TrdSubType_OFF_HOURS_TRADE_get, Swig_var_TrdSubType_OFF_HOURS_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_REJECT_FOR_SUBMITTING_SIDE",Swig_var_TrdSubType_REJECT_FOR_SUBMITTING_SIDE_get, Swig_var_TrdSubType_REJECT_FOR_SUBMITTING_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_ONSET_DUT_TO_AN_ALLOCATION",Swig_var_TrdSubType_ONSET_DUT_TO_AN_ALLOCATION_get, Swig_var_TrdSubType_ONSET_DUT_TO_AN_ALLOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_AI",Swig_var_TrdSubType_AI_get, Swig_var_TrdSubType_AI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_PC",Swig_var_TrdSubType_PC_get, Swig_var_TrdSubType_PC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_PN",Swig_var_TrdSubType_PN_get, Swig_var_TrdSubType_PN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_LARGE_IN_SCALE",Swig_var_TrdSubType_LARGE_IN_SCALE_get, Swig_var_TrdSubType_LARGE_IN_SCALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_NM",Swig_var_TrdSubType_NM_get, Swig_var_TrdSubType_NM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_T",Swig_var_TrdSubType_T_get, Swig_var_TrdSubType_T_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdSubType_ACATS",Swig_var_TrdSubType_ACATS_get, Swig_var_TrdSubType_ACATS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecTransType_NEW",Swig_var_ExecTransType_NEW_get, Swig_var_ExecTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecTransType_CORRECT",Swig_var_ExecTransType_CORRECT_get, Swig_var_ExecTransType_CORRECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecTransType_CANCEL",Swig_var_ExecTransType_CANCEL_get, Swig_var_ExecTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecTransType_STATUS",Swig_var_ExecTransType_STATUS_get, Swig_var_ExecTransType_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR",Swig_var_DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_get, Swig_var_DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DayBookingInst_ACCUMULATE",Swig_var_DayBookingInst_ACCUMULATE_get, Swig_var_DayBookingInst_ACCUMULATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING",Swig_var_DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_get, Swig_var_DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FlowScheduleType_NERC_EASTERN_OFF_PEAK",Swig_var_FlowScheduleType_NERC_EASTERN_OFF_PEAK_get, Swig_var_FlowScheduleType_NERC_EASTERN_OFF_PEAK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FlowScheduleType_NERC_WESTERN_PEAK",Swig_var_FlowScheduleType_NERC_WESTERN_PEAK_get, Swig_var_FlowScheduleType_NERC_WESTERN_PEAK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FlowScheduleType_NERC_EASTERN_PEAK",Swig_var_FlowScheduleType_NERC_EASTERN_PEAK_get, Swig_var_FlowScheduleType_NERC_EASTERN_PEAK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH",Swig_var_FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH_get, Swig_var_FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FlowScheduleType_NERC_WESTERN_OFF_PEAK",Swig_var_FlowScheduleType_NERC_WESTERN_OFF_PEAK_get, Swig_var_FlowScheduleType_NERC_WESTERN_OFF_PEAK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDOriginType_CROSS",Swig_var_MDOriginType_CROSS_get, Swig_var_MDOriginType_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDOriginType_OFF_BOOK",Swig_var_MDOriginType_OFF_BOOK_get, Swig_var_MDOriginType_OFF_BOOK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDOriginType_BOOK",Swig_var_MDOriginType_BOOK_get, Swig_var_MDOriginType_BOOK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryStatus_COMPLETED",Swig_var_CollInquiryStatus_COMPLETED_get, Swig_var_CollInquiryStatus_COMPLETED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryStatus_ACCEPTED_WITH_WARNINGS",Swig_var_CollInquiryStatus_ACCEPTED_WITH_WARNINGS_get, Swig_var_CollInquiryStatus_ACCEPTED_WITH_WARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryStatus_REJECTED",Swig_var_CollInquiryStatus_REJECTED_get, Swig_var_CollInquiryStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryStatus_ACCEPTED",Swig_var_CollInquiryStatus_ACCEPTED_get, Swig_var_CollInquiryStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollInquiryStatus_COMPLETED_WITH_WARNINGS",Swig_var_CollInquiryStatus_COMPLETED_WITH_WARNINGS_get, Swig_var_CollInquiryStatus_COMPLETED_WITH_WARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CPProgram_OTHER",Swig_var_CPProgram_OTHER_get, Swig_var_CPProgram_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CPProgram_3",Swig_var_CPProgram_3_get, Swig_var_CPProgram_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CPProgram_4",Swig_var_CPProgram_4_get, Swig_var_CPProgram_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqType_POSITIONS",Swig_var_PosReqType_POSITIONS_get, Swig_var_PosReqType_POSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqType_BACKOUT_MESSAGE",Swig_var_PosReqType_BACKOUT_MESSAGE_get, Swig_var_PosReqType_BACKOUT_MESSAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqType_DELTA_POSITIONS",Swig_var_PosReqType_DELTA_POSITIONS_get, Swig_var_PosReqType_DELTA_POSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqType_SETTLEMENT_ACTIVITY",Swig_var_PosReqType_SETTLEMENT_ACTIVITY_get, Swig_var_PosReqType_SETTLEMENT_ACTIVITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqType_TRADES",Swig_var_PosReqType_TRADES_get, Swig_var_PosReqType_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqType_EXERCISES",Swig_var_PosReqType_EXERCISES_get, Swig_var_PosReqType_EXERCISES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqType_ASSIGNMENTS",Swig_var_PosReqType_ASSIGNMENTS_get, Swig_var_PosReqType_ASSIGNMENTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY",Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY_get, Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY",Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_get, Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE",Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE_get, Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID",Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID_get, Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_SECURITY_ISSUER",Swig_var_MassStatusReqType_STATUS_FOR_SECURITY_ISSUER_get, Swig_var_MassStatusReqType_STATUS_FOR_SECURITY_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION",Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION_get, Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT",Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT_get, Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE",Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE_get, Swig_var_MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ALL_ORDERS",Swig_var_MassStatusReqType_STATUS_FOR_ALL_ORDERS_get, Swig_var_MassStatusReqType_STATUS_FOR_ALL_ORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY",Swig_var_MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST",Swig_var_SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST_get, Swig_var_SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES",Swig_var_SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES_get, Swig_var_SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SubscriptionRequestType_SNAPSHOT",Swig_var_SubscriptionRequestType_SNAPSHOT_get, Swig_var_SubscriptionRequestType_SNAPSHOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsCategory_MARKETPLACE_NEWS",Swig_var_NewsCategory_MARKETPLACE_NEWS_get, Swig_var_NewsCategory_MARKETPLACE_NEWS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsCategory_TECHNICAL_NEWS",Swig_var_NewsCategory_TECHNICAL_NEWS_get, Swig_var_NewsCategory_TECHNICAL_NEWS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsCategory_COMPANY_NEWS",Swig_var_NewsCategory_COMPANY_NEWS_get, Swig_var_NewsCategory_COMPANY_NEWS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsCategory_OTHER_NEWS",Swig_var_NewsCategory_OTHER_NEWS_get, Swig_var_NewsCategory_OTHER_NEWS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsCategory_FINANCIAL_MARKET_NEWS",Swig_var_NewsCategory_FINANCIAL_MARKET_NEWS_get, Swig_var_NewsCategory_FINANCIAL_MARKET_NEWS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQty_MEDIUM",Swig_var_IOIQty_MEDIUM_get, Swig_var_IOIQty_MEDIUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQty_LARGE",Swig_var_IOIQty_LARGE_get, Swig_var_IOIQty_LARGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQty_SMALL",Swig_var_IOIQty_SMALL_get, Swig_var_IOIQty_SMALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQty_UNDISCLOSED_QUANTITY",Swig_var_IOIQty_UNDISCLOSED_QUANTITY_get, Swig_var_IOIQty_UNDISCLOSED_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION",Swig_var_ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION_get, Swig_var_ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplResponseError_APPLICATION_DOES_NOT_EXIST",Swig_var_ApplResponseError_APPLICATION_DOES_NOT_EXIST_get, Swig_var_ApplResponseError_APPLICATION_DOES_NOT_EXIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE",Swig_var_ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE_get, Swig_var_ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_DOWN_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE",Swig_var_TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_DOWN_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE_get, Swig_var_TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_DOWN_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_UP_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE",Swig_var_TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_UP_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE_get, Swig_var_TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_UP_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastLiquidityInd_LIQUIDITY_ROUTED_OUT",Swig_var_LastLiquidityInd_LIQUIDITY_ROUTED_OUT_get, Swig_var_LastLiquidityInd_LIQUIDITY_ROUTED_OUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastLiquidityInd_AUCTION",Swig_var_LastLiquidityInd_AUCTION_get, Swig_var_LastLiquidityInd_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastLiquidityInd_ADDED_LIQUIDITY",Swig_var_LastLiquidityInd_ADDED_LIQUIDITY_get, Swig_var_LastLiquidityInd_ADDED_LIQUIDITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastLiquidityInd_REMOVED_LIQUIDITY",Swig_var_LastLiquidityInd_REMOVED_LIQUIDITY_get, Swig_var_LastLiquidityInd_REMOVED_LIQUIDITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_OF_UNDERLYING_SETTLEMENT_PRICE_ACROSS_THE_LIFE_OF_THE_OPTION",Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_OF_UNDERLYING_SETTLEMENT_PRICE_ACROSS_THE_LIFE_OF_THE_OPTION_get, Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_OF_UNDERLYING_SETTLEMENT_PRICE_ACROSS_THE_LIFE_OF_THE_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE",Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE_get, Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrikePriceDeterminationMethod_FIXED_STRIKE",Swig_var_StrikePriceDeterminationMethod_FIXED_STRIKE_get, Swig_var_StrikePriceDeterminationMethod_FIXED_STRIKE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE",Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE_get, Swig_var_StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TargetStrategy_PARTICIPATE",Swig_var_TargetStrategy_PARTICIPATE_get, Swig_var_TargetStrategy_PARTICIPATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TargetStrategy_MININIZE_MARKET_IMPACT",Swig_var_TargetStrategy_MININIZE_MARKET_IMPACT_get, Swig_var_TargetStrategy_MININIZE_MARKET_IMPACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TargetStrategy_VWAP",Swig_var_TargetStrategy_VWAP_get, Swig_var_TargetStrategy_VWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DueToRelated_NO",Swig_var_DueToRelated_NO_get, Swig_var_DueToRelated_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DueToRelated_YES",Swig_var_DueToRelated_YES_get, Swig_var_DueToRelated_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingCashType_DIFF",Swig_var_UnderlyingCashType_DIFF_get, Swig_var_UnderlyingCashType_DIFF_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingCashType_FIXED",Swig_var_UnderlyingCashType_FIXED_get, Swig_var_UnderlyingCashType_FIXED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT",Swig_var_CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_get, Swig_var_CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT",Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_get, Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER",Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_get, Swig_var_CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderCapacity_ALL_OTHER",Swig_var_CustOrderCapacity_ALL_OTHER_get, Swig_var_CustOrderCapacity_ALL_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnershipType_JOINT_TRUSTEES",Swig_var_OwnershipType_JOINT_TRUSTEES_get, Swig_var_OwnershipType_JOINT_TRUSTEES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnershipType_JOINT_INVESTORS",Swig_var_OwnershipType_JOINT_INVESTORS_get, Swig_var_OwnershipType_JOINT_INVESTORS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnershipType_TENANTS_IN_COMMON",Swig_var_OwnershipType_TENANTS_IN_COMMON_get, Swig_var_OwnershipType_TENANTS_IN_COMMON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_US_DOLLARS",Swig_var_UnitOfMeasure_US_DOLLARS_get, Swig_var_UnitOfMeasure_US_DOLLARS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_TONS",Swig_var_UnitOfMeasure_TONS_get, Swig_var_UnitOfMeasure_TONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_TROY_OUNCES",Swig_var_UnitOfMeasure_TROY_OUNCES_get, Swig_var_UnitOfMeasure_TROY_OUNCES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_MEGAWATT_HOURS",Swig_var_UnitOfMeasure_MEGAWATT_HOURS_get, Swig_var_UnitOfMeasure_MEGAWATT_HOURS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_ONE_MILLION_BTU",Swig_var_UnitOfMeasure_ONE_MILLION_BTU_get, Swig_var_UnitOfMeasure_ONE_MILLION_BTU_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_BILLION_CUBIC_FEET",Swig_var_UnitOfMeasure_BILLION_CUBIC_FEET_get, Swig_var_UnitOfMeasure_BILLION_CUBIC_FEET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_MILLION_BARRELS",Swig_var_UnitOfMeasure_MILLION_BARRELS_get, Swig_var_UnitOfMeasure_MILLION_BARRELS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_GALLONS",Swig_var_UnitOfMeasure_GALLONS_get, Swig_var_UnitOfMeasure_GALLONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_BARRELS",Swig_var_UnitOfMeasure_BARRELS_get, Swig_var_UnitOfMeasure_BARRELS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_POUNDS",Swig_var_UnitOfMeasure_POUNDS_get, Swig_var_UnitOfMeasure_POUNDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_METRIC_TONS",Swig_var_UnitOfMeasure_METRIC_TONS_get, Swig_var_UnitOfMeasure_METRIC_TONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_ALLOWANCES",Swig_var_UnitOfMeasure_ALLOWANCES_get, Swig_var_UnitOfMeasure_ALLOWANCES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnitOfMeasure_BUSHELS",Swig_var_UnitOfMeasure_BUSHELS_get, Swig_var_UnitOfMeasure_BUSHELS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_WHEN_AND_IF_ISSUED",Swig_var_SettlmntTyp_WHEN_AND_IF_ISSUED_get, Swig_var_SettlmntTyp_WHEN_AND_IF_ISSUED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_T_PLUS_1",Swig_var_SettlmntTyp_T_PLUS_1_get, Swig_var_SettlmntTyp_T_PLUS_1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_FUTURE",Swig_var_SettlmntTyp_FUTURE_get, Swig_var_SettlmntTyp_FUTURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_SELLERS_OPTION",Swig_var_SettlmntTyp_SELLERS_OPTION_get, Swig_var_SettlmntTyp_SELLERS_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_T_PLUS_2",Swig_var_SettlmntTyp_T_PLUS_2_get, Swig_var_SettlmntTyp_T_PLUS_2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_T_PLUS_3",Swig_var_SettlmntTyp_T_PLUS_3_get, Swig_var_SettlmntTyp_T_PLUS_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_T_PLUS_4",Swig_var_SettlmntTyp_T_PLUS_4_get, Swig_var_SettlmntTyp_T_PLUS_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_REGULAR",Swig_var_SettlmntTyp_REGULAR_get, Swig_var_SettlmntTyp_REGULAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_T_PLUS_5",Swig_var_SettlmntTyp_T_PLUS_5_get, Swig_var_SettlmntTyp_T_PLUS_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_WHEN_ISSUED",Swig_var_SettlmntTyp_WHEN_ISSUED_get, Swig_var_SettlmntTyp_WHEN_ISSUED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_NEXT_DAY",Swig_var_SettlmntTyp_NEXT_DAY_get, Swig_var_SettlmntTyp_NEXT_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlmntTyp_CASH",Swig_var_SettlmntTyp_CASH_get, Swig_var_SettlmntTyp_CASH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradePublishIndicator_DO_NOT_PUBLISH_TRADE",Swig_var_TradePublishIndicator_DO_NOT_PUBLISH_TRADE_get, Swig_var_TradePublishIndicator_DO_NOT_PUBLISH_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradePublishIndicator_DEFERRED_PUBLICATION",Swig_var_TradePublishIndicator_DEFERRED_PUBLICATION_get, Swig_var_TradePublishIndicator_DEFERRED_PUBLICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradePublishIndicator_PUBLISH_TRADE",Swig_var_TradePublishIndicator_PUBLISH_TRADE_get, Swig_var_TradePublishIndicator_PUBLISH_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplResponseType_MESSAGES_NOT_AVAILABLE",Swig_var_ApplResponseType_MESSAGES_NOT_AVAILABLE_get, Swig_var_ApplResponseType_MESSAGES_NOT_AVAILABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplResponseType_APPLICATION_DOES_NOT_EXIST",Swig_var_ApplResponseType_APPLICATION_DOES_NOT_EXIST_get, Swig_var_ApplResponseType_APPLICATION_DOES_NOT_EXIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED",Swig_var_ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED_get, Swig_var_ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StandInstDbType_DTC_SID",Swig_var_StandInstDbType_DTC_SID_get, Swig_var_StandInstDbType_DTC_SID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StandInstDbType_ACCOUNTNET",Swig_var_StandInstDbType_ACCOUNTNET_get, Swig_var_StandInstDbType_ACCOUNTNET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StandInstDbType_A_GLOBAL_CUSTODIAN",Swig_var_StandInstDbType_A_GLOBAL_CUSTODIAN_get, Swig_var_StandInstDbType_A_GLOBAL_CUSTODIAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StandInstDbType_THOMSON_ALERT",Swig_var_StandInstDbType_THOMSON_ALERT_get, Swig_var_StandInstDbType_THOMSON_ALERT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StandInstDbType_OTHER",Swig_var_StandInstDbType_OTHER_get, Swig_var_StandInstDbType_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_CROSS_MARKET_WARNING",Swig_var_QuoteEntryStatus_CROSS_MARKET_WARNING_get, Swig_var_QuoteEntryStatus_CROSS_MARKET_WARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_LOCKED_MARKET_WARNING",Swig_var_QuoteEntryStatus_LOCKED_MARKET_WARNING_get, Swig_var_QuoteEntryStatus_LOCKED_MARKET_WARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET",Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET_get, Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET",Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET_get, Swig_var_QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_REJECTED",Swig_var_QuoteEntryStatus_REJECTED_get, Swig_var_QuoteEntryStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_EXPIRED",Swig_var_QuoteEntryStatus_EXPIRED_get, Swig_var_QuoteEntryStatus_EXPIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_REMOVED_FROM_MARKET",Swig_var_QuoteEntryStatus_REMOVED_FROM_MARKET_get, Swig_var_QuoteEntryStatus_REMOVED_FROM_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_ACCEPTED",Swig_var_QuoteEntryStatus_ACCEPTED_get, Swig_var_QuoteEntryStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteEntryStatus_ACTIVE",Swig_var_QuoteEntryStatus_ACTIVE_get, Swig_var_QuoteEntryStatus_ACTIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceType_BEST_MID",Swig_var_TriggerPriceType_BEST_MID_get, Swig_var_TriggerPriceType_BEST_MID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceType_BEST_BID_OR_LAST_TRADE",Swig_var_TriggerPriceType_BEST_BID_OR_LAST_TRADE_get, Swig_var_TriggerPriceType_BEST_BID_OR_LAST_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceType_BEST_BID",Swig_var_TriggerPriceType_BEST_BID_get, Swig_var_TriggerPriceType_BEST_BID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceType_BEST_OFFER_OR_LAST_TRADE",Swig_var_TriggerPriceType_BEST_OFFER_OR_LAST_TRADE_get, Swig_var_TriggerPriceType_BEST_OFFER_OR_LAST_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceType_BEST_OFFER",Swig_var_TriggerPriceType_BEST_OFFER_get, Swig_var_TriggerPriceType_BEST_OFFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceType_LAST_TRADE",Swig_var_TriggerPriceType_LAST_TRADE_get, Swig_var_TriggerPriceType_LAST_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST",Swig_var_SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST_get, Swig_var_SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND",Swig_var_SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND_get, Swig_var_SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstReqRejCode_UNKNOWN_ACCOUNT",Swig_var_SettlInstReqRejCode_UNKNOWN_ACCOUNT_get, Swig_var_SettlInstReqRejCode_UNKNOWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstReqRejCode_OTHER",Swig_var_SettlInstReqRejCode_OTHER_get, Swig_var_SettlInstReqRejCode_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Urgency_FLASH",Swig_var_Urgency_FLASH_get, Swig_var_Urgency_FLASH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Urgency_NORMAL",Swig_var_Urgency_NORMAL_get, Swig_var_Urgency_NORMAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Urgency_BACKGROUND",Swig_var_Urgency_BACKGROUND_get, Swig_var_Urgency_BACKGROUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnTransType_REPLACE",Swig_var_CollAsgnTransType_REPLACE_get, Swig_var_CollAsgnTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnTransType_NEW",Swig_var_CollAsgnTransType_NEW_get, Swig_var_CollAsgnTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnTransType_REVERSE",Swig_var_CollAsgnTransType_REVERSE_get, Swig_var_CollAsgnTransType_REVERSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnTransType_CANCEL",Swig_var_CollAsgnTransType_CANCEL_get, Swig_var_CollAsgnTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnTransType_RELEASE",Swig_var_CollAsgnTransType_RELEASE_get, Swig_var_CollAsgnTransType_RELEASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_FED_WIRE",Swig_var_PaymentMethod_FED_WIRE_get, Swig_var_PaymentMethod_FED_WIRE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_EUROCLEAR",Swig_var_PaymentMethod_EUROCLEAR_get, Swig_var_PaymentMethod_EUROCLEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_ACH_CREDIT",Swig_var_PaymentMethod_ACH_CREDIT_get, Swig_var_PaymentMethod_ACH_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_TELEGRAPHIC_TRANSFER",Swig_var_PaymentMethod_TELEGRAPHIC_TRANSFER_get, Swig_var_PaymentMethod_TELEGRAPHIC_TRANSFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_FEDWIRE",Swig_var_PaymentMethod_FEDWIRE_get, Swig_var_PaymentMethod_FEDWIRE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_DIRECT_DEBIT",Swig_var_PaymentMethod_DIRECT_DEBIT_get, Swig_var_PaymentMethod_DIRECT_DEBIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_CREDIT_CARD",Swig_var_PaymentMethod_CREDIT_CARD_get, Swig_var_PaymentMethod_CREDIT_CARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_CHEQUE",Swig_var_PaymentMethod_CHEQUE_get, Swig_var_PaymentMethod_CHEQUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_DIRECT_CREDIT",Swig_var_PaymentMethod_DIRECT_CREDIT_get, Swig_var_PaymentMethod_DIRECT_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_CREST",Swig_var_PaymentMethod_CREST_get, Swig_var_PaymentMethod_CREST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM",Swig_var_PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_get, Swig_var_PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_CLEARSTREAM",Swig_var_PaymentMethod_CLEARSTREAM_get, Swig_var_PaymentMethod_CLEARSTREAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_BPAY",Swig_var_PaymentMethod_BPAY_get, Swig_var_PaymentMethod_BPAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_NSCC",Swig_var_PaymentMethod_NSCC_get, Swig_var_PaymentMethod_NSCC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_DEBIT_CARD",Swig_var_PaymentMethod_DEBIT_CARD_get, Swig_var_PaymentMethod_DEBIT_CARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PaymentMethod_ACH_DEBIT",Swig_var_PaymentMethod_ACH_DEBIT_get, Swig_var_PaymentMethod_ACH_DEBIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceTypeScope_LOCAL",Swig_var_TriggerPriceTypeScope_LOCAL_get, Swig_var_TriggerPriceTypeScope_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceTypeScope_NONE",Swig_var_TriggerPriceTypeScope_NONE_get, Swig_var_TriggerPriceTypeScope_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceTypeScope_GLOBAL",Swig_var_TriggerPriceTypeScope_GLOBAL_get, Swig_var_TriggerPriceTypeScope_GLOBAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerPriceTypeScope_NATIONAL",Swig_var_TriggerPriceTypeScope_NATIONAL_get, Swig_var_TriggerPriceTypeScope_NATIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegLimitType_STRICT",Swig_var_PegLimitType_STRICT_get, Swig_var_PegLimitType_STRICT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegLimitType_OR_BETTER",Swig_var_PegLimitType_OR_BETTER_get, Swig_var_PegLimitType_OR_BETTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegLimitType_OR_WORSE",Swig_var_PegLimitType_OR_WORSE_get, Swig_var_PegLimitType_OR_WORSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT",Swig_var_PegLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT_get, Swig_var_PegLimitType_STRICT_LIMIT_IS_A_STRICT_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegLimitType_OR_WORSE_FOR_A_BUY_THE_PEG_LIMIT_IS_A_MINIMUM_AND_FOR_A_SELL_THE_PEG_LIMIT_IS_A_MAXIMUM",Swig_var_PegLimitType_OR_WORSE_FOR_A_BUY_THE_PEG_LIMIT_IS_A_MINIMUM_AND_FOR_A_SELL_THE_PEG_LIMIT_IS_A_MAXIMUM_get, Swig_var_PegLimitType_OR_WORSE_FOR_A_BUY_THE_PEG_LIMIT_IS_A_MINIMUM_AND_FOR_A_SELL_THE_PEG_LIMIT_IS_A_MAXIMUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_BORROW",Swig_var_Side_BORROW_get, Swig_var_Side_BORROW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_BUY_MINUS",Swig_var_Side_BUY_MINUS_get, Swig_var_Side_BUY_MINUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_SUBSCRIBE",Swig_var_Side_SUBSCRIBE_get, Swig_var_Side_SUBSCRIBE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_CROSS_SHORT_EXEMPT",Swig_var_Side_CROSS_SHORT_EXEMPT_get, Swig_var_Side_CROSS_SHORT_EXEMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_UNDISCLOSED",Swig_var_Side_UNDISCLOSED_get, Swig_var_Side_UNDISCLOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_CROSS",Swig_var_Side_CROSS_get, Swig_var_Side_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_SELL_SHORT_EXEMPT",Swig_var_Side_SELL_SHORT_EXEMPT_get, Swig_var_Side_SELL_SHORT_EXEMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_BUY",Swig_var_Side_BUY_get, Swig_var_Side_BUY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_CROSS_SHORT_EXXMPT",Swig_var_Side_CROSS_SHORT_EXXMPT_get, Swig_var_Side_CROSS_SHORT_EXXMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_SELL",Swig_var_Side_SELL_get, Swig_var_Side_SELL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_LEND",Swig_var_Side_LEND_get, Swig_var_Side_LEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_SELL_SHORT",Swig_var_Side_SELL_SHORT_get, Swig_var_Side_SELL_SHORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_OPPOSITE",Swig_var_Side_OPPOSITE_get, Swig_var_Side_OPPOSITE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_CROSS_SHORT",Swig_var_Side_CROSS_SHORT_get, Swig_var_Side_CROSS_SHORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_SELL_PLUS",Swig_var_Side_SELL_PLUS_get, Swig_var_Side_SELL_PLUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_REDEEM",Swig_var_Side_REDEEM_get, Swig_var_Side_REDEEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Side_AS_DEFINED",Swig_var_Side_AS_DEFINED_get, Swig_var_Side_AS_DEFINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_EXIT_CHARGE",Swig_var_ContAmtType_EXIT_CHARGE_get, Swig_var_ContAmtType_EXIT_CHARGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DILUTION_LEVY_AMOUNT",Swig_var_ContAmtType_DILUTION_LEVY_AMOUNT_get, Swig_var_ContAmtType_DILUTION_LEVY_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DILUTION_LEVY_PERCENT",Swig_var_ContAmtType_DILUTION_LEVY_PERCENT_get, Swig_var_ContAmtType_DILUTION_LEVY_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DISCOUNT_AMOUNT",Swig_var_ContAmtType_DISCOUNT_AMOUNT_get, Swig_var_ContAmtType_DISCOUNT_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_COMMISSION",Swig_var_ContAmtType_COMMISSION_get, Swig_var_ContAmtType_COMMISSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_INITIAL_CHARGE_PERCENT",Swig_var_ContAmtType_INITIAL_CHARGE_PERCENT_get, Swig_var_ContAmtType_INITIAL_CHARGE_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DILUTION_LEVY",Swig_var_ContAmtType_DILUTION_LEVY_get, Swig_var_ContAmtType_DILUTION_LEVY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_COMMISSION_AMOUNT",Swig_var_ContAmtType_COMMISSION_AMOUNT_get, Swig_var_ContAmtType_COMMISSION_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_NET_SETTLEMENT_AMOUNT",Swig_var_ContAmtType_NET_SETTLEMENT_AMOUNT_get, Swig_var_ContAmtType_NET_SETTLEMENT_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_FUND_BASED_RENEWAL_COMMISSION",Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_get, Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DISCOUNT",Swig_var_ContAmtType_DISCOUNT_get, Swig_var_ContAmtType_DISCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13",Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13_get, Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_EXIT_CHARGE_AMOUNT",Swig_var_ContAmtType_EXIT_CHARGE_AMOUNT_get, Swig_var_ContAmtType_EXIT_CHARGE_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_INITIAL_CHARGE",Swig_var_ContAmtType_INITIAL_CHARGE_get, Swig_var_ContAmtType_INITIAL_CHARGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_DISCOUNT_PERCENT",Swig_var_ContAmtType_DISCOUNT_PERCENT_get, Swig_var_ContAmtType_DISCOUNT_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_EXIT_CHARGE_PERCENT",Swig_var_ContAmtType_EXIT_CHARGE_PERCENT_get, Swig_var_ContAmtType_EXIT_CHARGE_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14",Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14_get, Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_COMMISSION_PERCENT",Swig_var_ContAmtType_COMMISSION_PERCENT_get, Swig_var_ContAmtType_COMMISSION_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT",Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT_get, Swig_var_ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_PROJECTED_FUND_VALUE",Swig_var_ContAmtType_PROJECTED_FUND_VALUE_get, Swig_var_ContAmtType_PROJECTED_FUND_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContAmtType_INITIAL_CHARGE_AMOUNT",Swig_var_ContAmtType_INITIAL_CHARGE_AMOUNT_get, Swig_var_ContAmtType_INITIAL_CHARGE_AMOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_IMPLIED_ORDER",Swig_var_OrderCategory_IMPLIED_ORDER_get, Swig_var_OrderCategory_IMPLIED_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_STREAMING_PRICE",Swig_var_OrderCategory_STREAMING_PRICE_get, Swig_var_OrderCategory_STREAMING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_QUOTE_REQUEST",Swig_var_OrderCategory_QUOTE_REQUEST_get, Swig_var_OrderCategory_QUOTE_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_CROSS_ORDER",Swig_var_OrderCategory_CROSS_ORDER_get, Swig_var_OrderCategory_CROSS_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_MULTILEG_ORDER",Swig_var_OrderCategory_MULTILEG_ORDER_get, Swig_var_OrderCategory_MULTILEG_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_PRIVATELY_NEGOTIATED_TRADE",Swig_var_OrderCategory_PRIVATELY_NEGOTIATED_TRADE_get, Swig_var_OrderCategory_PRIVATELY_NEGOTIATED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_QUOTE",Swig_var_OrderCategory_QUOTE_get, Swig_var_OrderCategory_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_ORDER",Swig_var_OrderCategory_ORDER_get, Swig_var_OrderCategory_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderCategory_LINKED_ORDER",Swig_var_OrderCategory_LINKED_ORDER_get, Swig_var_OrderCategory_LINKED_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvTransType_REPLACE",Swig_var_AdvTransType_REPLACE_get, Swig_var_AdvTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvTransType_NEW",Swig_var_AdvTransType_NEW_get, Swig_var_AdvTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AdvTransType_CANCEL",Swig_var_AdvTransType_CANCEL_get, Swig_var_AdvTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PublishTrdIndicator_NO",Swig_var_PublishTrdIndicator_NO_get, Swig_var_PublishTrdIndicator_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PublishTrdIndicator_YES",Swig_var_PublishTrdIndicator_YES_get, Swig_var_PublishTrdIndicator_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST",Swig_var_SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST_get, Swig_var_SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST",Swig_var_SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST_get, Swig_var_SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_WITH_REVISIONS_AS_INDICATED_IN_THE_MESSAGE",Swig_var_SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_WITH_REVISIONS_AS_INDICATED_IN_THE_MESSAGE_get, Swig_var_SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_WITH_REVISIONS_AS_INDICATED_IN_THE_MESSAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS",Swig_var_SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS_get, Swig_var_SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_REJECT_SECURITY_PROPOSAL",Swig_var_SecurityResponseType_REJECT_SECURITY_PROPOSAL_get, Swig_var_SecurityResponseType_REJECT_SECURITY_PROPOSAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA",Swig_var_SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA_get, Swig_var_SecurityResponseType_CAN_NOT_MATCH_SELECTION_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA",Swig_var_SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA_get, Swig_var_SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_PASSWORD_EXPIRED",Swig_var_SessionStatus_PASSWORD_EXPIRED_get, Swig_var_SessionStatus_PASSWORD_EXPIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_SESSION_LOGOUT_COMPLETE",Swig_var_SessionStatus_SESSION_LOGOUT_COMPLETE_get, Swig_var_SessionStatus_SESSION_LOGOUT_COMPLETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_INVALID_USERNAME_OR_PASSWORD",Swig_var_SessionStatus_INVALID_USERNAME_OR_PASSWORD_get, Swig_var_SessionStatus_INVALID_USERNAME_OR_PASSWORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_SESSION_ACTIVE",Swig_var_SessionStatus_SESSION_ACTIVE_get, Swig_var_SessionStatus_SESSION_ACTIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_SESSION_PASSWORD_CHANGED",Swig_var_SessionStatus_SESSION_PASSWORD_CHANGED_get, Swig_var_SessionStatus_SESSION_PASSWORD_CHANGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_ACCOUNT_LOCKED",Swig_var_SessionStatus_ACCOUNT_LOCKED_get, Swig_var_SessionStatus_ACCOUNT_LOCKED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME",Swig_var_SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME_get, Swig_var_SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE",Swig_var_SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE_get, Swig_var_SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY",Swig_var_SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY_get, Swig_var_SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_HOUSE_TRADER",Swig_var_AllocAccountType_HOUSE_TRADER_get, Swig_var_AllocAccountType_HOUSE_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_FLOOR_TRADER",Swig_var_AllocAccountType_FLOOR_TRADER_get, Swig_var_AllocAccountType_FLOOR_TRADER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS",Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_get, Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT",Swig_var_AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT_get, Swig_var_AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED",Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_get, Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS",Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_get, Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS",Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS_get, Swig_var_AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_JOINT_BACKOFFICE_ACCOUNT",Swig_var_AllocAccountType_JOINT_BACKOFFICE_ACCOUNT_get, Swig_var_AllocAccountType_JOINT_BACKOFFICE_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED",Swig_var_AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_get, Swig_var_AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_REPLACE",Swig_var_AllocTransType_REPLACE_get, Swig_var_AllocTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_NEW",Swig_var_AllocTransType_NEW_get, Swig_var_AllocTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_CALCULATED",Swig_var_AllocTransType_CALCULATED_get, Swig_var_AllocTransType_CALCULATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_PRELIMINARY",Swig_var_AllocTransType_PRELIMINARY_get, Swig_var_AllocTransType_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_CANCEL",Swig_var_AllocTransType_CANCEL_get, Swig_var_AllocTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_REVERSAL",Swig_var_AllocTransType_REVERSAL_get, Swig_var_AllocTransType_REVERSAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocTransType_CALCULATED_WITHOUT_PRELIMINARY",Swig_var_AllocTransType_CALCULATED_WITHOUT_PRELIMINARY_get, Swig_var_AllocTransType_CALCULATED_WITHOUT_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationQtyType_DIFFERENCE",Swig_var_ExpirationQtyType_DIFFERENCE_get, Swig_var_ExpirationQtyType_DIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationQtyType_FINAL_WILL_BE_EXERCISED",Swig_var_ExpirationQtyType_FINAL_WILL_BE_EXERCISED_get, Swig_var_ExpirationQtyType_FINAL_WILL_BE_EXERCISED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationQtyType_NON_AUTO_EXERCISE",Swig_var_ExpirationQtyType_NON_AUTO_EXERCISE_get, Swig_var_ExpirationQtyType_NON_AUTO_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationQtyType_CONTRARY_INTENTION",Swig_var_ExpirationQtyType_CONTRARY_INTENTION_get, Swig_var_ExpirationQtyType_CONTRARY_INTENTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExpirationQtyType_AUTO_EXERCISE",Swig_var_ExpirationQtyType_AUTO_EXERCISE_get, Swig_var_ExpirationQtyType_AUTO_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocHandlInst_FORWARD_AND_MATCH",Swig_var_AllocHandlInst_FORWARD_AND_MATCH_get, Swig_var_AllocHandlInst_FORWARD_AND_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocHandlInst_FORWARD",Swig_var_AllocHandlInst_FORWARD_get, Swig_var_AllocHandlInst_FORWARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocHandlInst_MATCH",Swig_var_AllocHandlInst_MATCH_get, Swig_var_AllocHandlInst_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestStatus_COMPLETED",Swig_var_TradeRequestStatus_COMPLETED_get, Swig_var_TradeRequestStatus_COMPLETED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestStatus_REJECTED",Swig_var_TradeRequestStatus_REJECTED_get, Swig_var_TradeRequestStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeRequestStatus_ACCEPTED",Swig_var_TradeRequestStatus_ACCEPTED_get, Swig_var_TradeRequestStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST",Swig_var_PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST_get, Swig_var_PreallocMethod_DO_NOT_PRO_RATA_DISCUSS_FIRST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PreallocMethod_PRO_RATA",Swig_var_PreallocMethod_PRO_RATA_get, Swig_var_PreallocMethod_PRO_RATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PreallocMethod_DO_NOT_PRO_RATA",Swig_var_PreallocMethod_DO_NOT_PRO_RATA_get, Swig_var_PreallocMethod_DO_NOT_PRO_RATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_457",Swig_var_TaxAdvantageType_457_get, Swig_var_TaxAdvantageType_457_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_MAXI_ISA",Swig_var_TaxAdvantageType_MAXI_ISA_get, Swig_var_TaxAdvantageType_MAXI_ISA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYEE_CURRENT_YEAR",Swig_var_TaxAdvantageType_EMPLOYEE_CURRENT_YEAR_get, Swig_var_TaxAdvantageType_EMPLOYEE_CURRENT_YEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYEE_9",Swig_var_TaxAdvantageType_EMPLOYEE_9_get, Swig_var_TaxAdvantageType_EMPLOYEE_9_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_403",Swig_var_TaxAdvantageType_403_get, Swig_var_TaxAdvantageType_403_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_KEOGH",Swig_var_TaxAdvantageType_KEOGH_get, Swig_var_TaxAdvantageType_KEOGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_401K",Swig_var_TaxAdvantageType_401K_get, Swig_var_TaxAdvantageType_401K_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_SELF_DIRECTED_IRA",Swig_var_TaxAdvantageType_SELF_DIRECTED_IRA_get, Swig_var_TaxAdvantageType_SELF_DIRECTED_IRA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN",Swig_var_TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN_get, Swig_var_TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16",Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16_get, Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ROTH_IRA_24",Swig_var_TaxAdvantageType_ROTH_IRA_24_get, Swig_var_TaxAdvantageType_ROTH_IRA_24_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_CURRENT_YEAR_PAYMENT",Swig_var_TaxAdvantageType_CURRENT_YEAR_PAYMENT_get, Swig_var_TaxAdvantageType_CURRENT_YEAR_PAYMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_MINI_INSURANCE_ISA",Swig_var_TaxAdvantageType_MINI_INSURANCE_ISA_get, Swig_var_TaxAdvantageType_MINI_INSURANCE_ISA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17",Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17_get, Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EDUCATION_IRA_28",Swig_var_TaxAdvantageType_EDUCATION_IRA_28_get, Swig_var_TaxAdvantageType_EDUCATION_IRA_28_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ROTH_IRA_25",Swig_var_TaxAdvantageType_ROTH_IRA_25_get, Swig_var_TaxAdvantageType_ROTH_IRA_25_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT",Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_get, Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYEE_10",Swig_var_TaxAdvantageType_EMPLOYEE_10_get, Swig_var_TaxAdvantageType_EMPLOYEE_10_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EDUCATION_IRA_29",Swig_var_TaxAdvantageType_EDUCATION_IRA_29_get, Swig_var_TaxAdvantageType_EDUCATION_IRA_29_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_PRIOR_YEAR_PAYMENT",Swig_var_TaxAdvantageType_PRIOR_YEAR_PAYMENT_get, Swig_var_TaxAdvantageType_PRIOR_YEAR_PAYMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER",Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER_get, Swig_var_TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_ROLLOVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYER_11",Swig_var_TaxAdvantageType_EMPLOYER_11_get, Swig_var_TaxAdvantageType_EMPLOYER_11_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ASSET_TRANSFER",Swig_var_TaxAdvantageType_ASSET_TRANSFER_get, Swig_var_TaxAdvantageType_ASSET_TRANSFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYER_12",Swig_var_TaxAdvantageType_EMPLOYER_12_get, Swig_var_TaxAdvantageType_EMPLOYER_12_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_OTHER",Swig_var_TaxAdvantageType_OTHER_get, Swig_var_TaxAdvantageType_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA",Swig_var_TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA_get, Swig_var_TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYEE",Swig_var_TaxAdvantageType_EMPLOYEE_get, Swig_var_TaxAdvantageType_EMPLOYEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ROTH_CONVERSION_IRA_26",Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_26_get, Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_26_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_MINI_CASH_ISA",Swig_var_TaxAdvantageType_MINI_CASH_ISA_get, Swig_var_TaxAdvantageType_MINI_CASH_ISA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_ROTH_CONVERSION_IRA_27",Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_27_get, Swig_var_TaxAdvantageType_ROTH_CONVERSION_IRA_27_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_NONE_NOT_APPLICABLE",Swig_var_TaxAdvantageType_NONE_NOT_APPLICABLE_get, Swig_var_TaxAdvantageType_NONE_NOT_APPLICABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_TESSA",Swig_var_TaxAdvantageType_TESSA_get, Swig_var_TaxAdvantageType_TESSA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_NON_FUND_QUALIFIED_PLAN",Swig_var_TaxAdvantageType_NON_FUND_QUALIFIED_PLAN_get, Swig_var_TaxAdvantageType_NON_FUND_QUALIFIED_PLAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYER_CURRENT_YEAR",Swig_var_TaxAdvantageType_EMPLOYER_CURRENT_YEAR_get, Swig_var_TaxAdvantageType_EMPLOYER_CURRENT_YEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_EMPLOYER",Swig_var_TaxAdvantageType_EMPLOYER_get, Swig_var_TaxAdvantageType_EMPLOYER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_PROFIT_SHARING_PLAN",Swig_var_TaxAdvantageType_PROFIT_SHARING_PLAN_get, Swig_var_TaxAdvantageType_PROFIT_SHARING_PLAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_401",Swig_var_TaxAdvantageType_401_get, Swig_var_TaxAdvantageType_401_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TaxAdvantageType_NON_FUND_PROTOTYPE_IRA",Swig_var_TaxAdvantageType_NON_FUND_PROTOTYPE_IRA_get, Swig_var_TaxAdvantageType_NON_FUND_PROTOTYPE_IRA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MessageEncoding_EUC_JP",Swig_var_MessageEncoding_EUC_JP_get, Swig_var_MessageEncoding_EUC_JP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MessageEncoding_SHIFT_JIS",Swig_var_MessageEncoding_SHIFT_JIS_get, Swig_var_MessageEncoding_SHIFT_JIS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MessageEncoding_UTF_8",Swig_var_MessageEncoding_UTF_8_get, Swig_var_MessageEncoding_UTF_8_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MessageEncoding_ISO_2022_JP",Swig_var_MessageEncoding_ISO_2022_JP_get, Swig_var_MessageEncoding_ISO_2022_JP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MessageEncoding_EUC",Swig_var_MessageEncoding_EUC_get, Swig_var_MessageEncoding_EUC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MessageEncoding_JIS",Swig_var_MessageEncoding_JIS_get, Swig_var_MessageEncoding_JIS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MessageEncoding_FOR_USING_SJIS",Swig_var_MessageEncoding_FOR_USING_SJIS_get, Swig_var_MessageEncoding_FOR_USING_SJIS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MessageEncoding_UNICODE",Swig_var_MessageEncoding_UNICODE_get, Swig_var_MessageEncoding_UNICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_GOOD_TILL_CROSSING",Swig_var_TimeInForce_GOOD_TILL_CROSSING_get, Swig_var_TimeInForce_GOOD_TILL_CROSSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_FILL_OR_KILL",Swig_var_TimeInForce_FILL_OR_KILL_get, Swig_var_TimeInForce_FILL_OR_KILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_GOOD_TILL_DATE",Swig_var_TimeInForce_GOOD_TILL_DATE_get, Swig_var_TimeInForce_GOOD_TILL_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_GOOD_TILL_CANCEL",Swig_var_TimeInForce_GOOD_TILL_CANCEL_get, Swig_var_TimeInForce_GOOD_TILL_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_DAY",Swig_var_TimeInForce_DAY_get, Swig_var_TimeInForce_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_AT_CROSSING",Swig_var_TimeInForce_AT_CROSSING_get, Swig_var_TimeInForce_AT_CROSSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_IMMEDIATE_OR_CANCEL",Swig_var_TimeInForce_IMMEDIATE_OR_CANCEL_get, Swig_var_TimeInForce_IMMEDIATE_OR_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_GOOD_THROUGH_CROSSING",Swig_var_TimeInForce_GOOD_THROUGH_CROSSING_get, Swig_var_TimeInForce_GOOD_THROUGH_CROSSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_AT_THE_CLOSE",Swig_var_TimeInForce_AT_THE_CLOSE_get, Swig_var_TimeInForce_AT_THE_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeInForce_AT_THE_OPENING",Swig_var_TimeInForce_AT_THE_OPENING_get, Swig_var_TimeInForce_AT_THE_OPENING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_THROUGH_THE_DAY",Swig_var_IOIQualifier_THROUGH_THE_DAY_get, Swig_var_IOIQualifier_THROUGH_THE_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_INDIDCATION",Swig_var_IOIQualifier_INDIDCATION_get, Swig_var_IOIQualifier_INDIDCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_AT_THE_MARKET",Swig_var_IOIQualifier_AT_THE_MARKET_get, Swig_var_IOIQualifier_AT_THE_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_AT_THE_MIDPOINT",Swig_var_IOIQualifier_AT_THE_MIDPOINT_get, Swig_var_IOIQualifier_AT_THE_MIDPOINT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_CROSSING_OPPORTUNITY",Swig_var_IOIQualifier_CROSSING_OPPORTUNITY_get, Swig_var_IOIQualifier_CROSSING_OPPORTUNITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_CURRENT_QUOTE",Swig_var_IOIQualifier_CURRENT_QUOTE_get, Swig_var_IOIQualifier_CURRENT_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_IN_TOUCH_WITH",Swig_var_IOIQualifier_IN_TOUCH_WITH_get, Swig_var_IOIQualifier_IN_TOUCH_WITH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_ALL_OR_NONE",Swig_var_IOIQualifier_ALL_OR_NONE_get, Swig_var_IOIQualifier_ALL_OR_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_TAKING_A_POSITION",Swig_var_IOIQualifier_TAKING_A_POSITION_get, Swig_var_IOIQualifier_TAKING_A_POSITION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_AT_THE_OPEN",Swig_var_IOIQualifier_AT_THE_OPEN_get, Swig_var_IOIQualifier_AT_THE_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_PORTFOLIO_SHOW_N",Swig_var_IOIQualifier_PORTFOLIO_SHOW_N_get, Swig_var_IOIQualifier_PORTFOLIO_SHOW_N_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_MARKET_ON_CLOSE",Swig_var_IOIQualifier_MARKET_ON_CLOSE_get, Swig_var_IOIQualifier_MARKET_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_VERSUS",Swig_var_IOIQualifier_VERSUS_get, Swig_var_IOIQualifier_VERSUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_LIMIT",Swig_var_IOIQualifier_LIMIT_get, Swig_var_IOIQualifier_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_PORTFOLIO_SHOWN",Swig_var_IOIQualifier_PORTFOLIO_SHOWN_get, Swig_var_IOIQualifier_PORTFOLIO_SHOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_READY_TO_TRADE",Swig_var_IOIQualifier_READY_TO_TRADE_get, Swig_var_IOIQualifier_READY_TO_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_PRE_OPEN",Swig_var_IOIQualifier_PRE_OPEN_get, Swig_var_IOIQualifier_PRE_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_INDICATION",Swig_var_IOIQualifier_INDICATION_get, Swig_var_IOIQualifier_INDICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_MORE_BEHIND",Swig_var_IOIQualifier_MORE_BEHIND_get, Swig_var_IOIQualifier_MORE_BEHIND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_VWAP",Swig_var_IOIQualifier_VWAP_get, Swig_var_IOIQualifier_VWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIQualifier_AT_THE_CLOSE",Swig_var_IOIQualifier_AT_THE_CLOSE_get, Swig_var_IOIQualifier_AT_THE_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY",Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY_get, Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrikePriceBoundaryMethod_GREATER_THAN_UNDERLYING_IS_IN_THE_MONEY",Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_UNDERLYING_IS_IN_THE_MONEY_get, Swig_var_StrikePriceBoundaryMethod_GREATER_THAN_UNDERLYING_IS_IN_THE_MONEY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY",Swig_var_StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_get, Swig_var_StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrikePriceBoundaryMethod_LESS_THAN_UNDERLYING_PRICE_IS_IN_THE_MONEY",Swig_var_StrikePriceBoundaryMethod_LESS_THAN_UNDERLYING_PRICE_IS_IN_THE_MONEY_get, Swig_var_StrikePriceBoundaryMethod_LESS_THAN_UNDERLYING_PRICE_IS_IN_THE_MONEY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY",Swig_var_StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_get, Swig_var_StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_CONVERSION",Swig_var_MiscFeeType_CONVERSION_get, Swig_var_MiscFeeType_CONVERSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_CONSUMPTION_TAX",Swig_var_MiscFeeType_CONSUMPTION_TAX_get, Swig_var_MiscFeeType_CONSUMPTION_TAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_LOCAL_COMMISSION",Swig_var_MiscFeeType_LOCAL_COMMISSION_get, Swig_var_MiscFeeType_LOCAL_COMMISSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_TAX",Swig_var_MiscFeeType_TAX_get, Swig_var_MiscFeeType_TAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_MARKUP",Swig_var_MiscFeeType_MARKUP_get, Swig_var_MiscFeeType_MARKUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_SECURITY_LENDING",Swig_var_MiscFeeType_SECURITY_LENDING_get, Swig_var_MiscFeeType_SECURITY_LENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_PER_TRANSACTION",Swig_var_MiscFeeType_PER_TRANSACTION_get, Swig_var_MiscFeeType_PER_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_REGULATORY",Swig_var_MiscFeeType_REGULATORY_get, Swig_var_MiscFeeType_REGULATORY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_STAMP",Swig_var_MiscFeeType_STAMP_get, Swig_var_MiscFeeType_STAMP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_TRANSFER_FEE",Swig_var_MiscFeeType_TRANSFER_FEE_get, Swig_var_MiscFeeType_TRANSFER_FEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_AGENT",Swig_var_MiscFeeType_AGENT_get, Swig_var_MiscFeeType_AGENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_OTHER",Swig_var_MiscFeeType_OTHER_get, Swig_var_MiscFeeType_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_EXCHANGE_FEES",Swig_var_MiscFeeType_EXCHANGE_FEES_get, Swig_var_MiscFeeType_EXCHANGE_FEES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeType_LEVY",Swig_var_MiscFeeType_LEVY_get, Swig_var_MiscFeeType_LEVY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY",Swig_var_SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_get, Swig_var_SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_CLEARING_HOUSE",Swig_var_SecurityIDSource_CLEARING_HOUSE_get, Swig_var_SecurityIDSource_CLEARING_HOUSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_EXCHANGE_SYMBOL",Swig_var_SecurityIDSource_EXCHANGE_SYMBOL_get, Swig_var_SecurityIDSource_EXCHANGE_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_SICOVAM",Swig_var_SecurityIDSource_SICOVAM_get, Swig_var_SecurityIDSource_SICOVAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_ISDA_FPML_PRODUCT_URL",Swig_var_SecurityIDSource_ISDA_FPML_PRODUCT_URL_get, Swig_var_SecurityIDSource_ISDA_FPML_PRODUCT_URL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION",Swig_var_SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION_get, Swig_var_SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_RIC_CODE",Swig_var_SecurityIDSource_RIC_CODE_get, Swig_var_SecurityIDSource_RIC_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_ISO_CURRENCY_CODE",Swig_var_SecurityIDSource_ISO_CURRENCY_CODE_get, Swig_var_SecurityIDSource_ISO_CURRENCY_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_COMMON",Swig_var_SecurityIDSource_COMMON_get, Swig_var_SecurityIDSource_COMMON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_VALOREN",Swig_var_SecurityIDSource_VALOREN_get, Swig_var_SecurityIDSource_VALOREN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_BELGIAN",Swig_var_SecurityIDSource_BELGIAN_get, Swig_var_SecurityIDSource_BELGIAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_OPTIONS_PRICE_REPORTING_AUTHORITY",Swig_var_SecurityIDSource_OPTIONS_PRICE_REPORTING_AUTHORITY_get, Swig_var_SecurityIDSource_OPTIONS_PRICE_REPORTING_AUTHORITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_ISIN_NUMBER",Swig_var_SecurityIDSource_ISIN_NUMBER_get, Swig_var_SecurityIDSource_ISIN_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_SEDOL",Swig_var_SecurityIDSource_SEDOL_get, Swig_var_SecurityIDSource_SEDOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_ISO_COUNTRY_CODE",Swig_var_SecurityIDSource_ISO_COUNTRY_CODE_get, Swig_var_SecurityIDSource_ISO_COUNTRY_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_LETTER_OF_CREDIT",Swig_var_SecurityIDSource_LETTER_OF_CREDIT_get, Swig_var_SecurityIDSource_LETTER_OF_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_BLOOMBERG_SYMBOL",Swig_var_SecurityIDSource_BLOOMBERG_SYMBOL_get, Swig_var_SecurityIDSource_BLOOMBERG_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_WERTPAPIER",Swig_var_SecurityIDSource_WERTPAPIER_get, Swig_var_SecurityIDSource_WERTPAPIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER",Swig_var_SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_get, Swig_var_SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION",Swig_var_SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_get, Swig_var_SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_DUTCH",Swig_var_SecurityIDSource_DUTCH_get, Swig_var_SecurityIDSource_DUTCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_QUIK",Swig_var_SecurityIDSource_QUIK_get, Swig_var_SecurityIDSource_QUIK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityIDSource_CUSIP",Swig_var_SecurityIDSource_CUSIP_get, Swig_var_SecurityIDSource_CUSIP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsRefType_OTHER_LANGUAGE",Swig_var_NewsRefType_OTHER_LANGUAGE_get, Swig_var_NewsRefType_OTHER_LANGUAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsRefType_COMPLIMENTARY",Swig_var_NewsRefType_COMPLIMENTARY_get, Swig_var_NewsRefType_COMPLIMENTARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NewsRefType_REPLACEMENT",Swig_var_NewsRefType_REPLACEMENT_get, Swig_var_NewsRefType_REPLACEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerOrderType_LIMIT",Swig_var_TriggerOrderType_LIMIT_get, Swig_var_TriggerOrderType_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TriggerOrderType_MARKET",Swig_var_TriggerOrderType_MARKET_get, Swig_var_TriggerOrderType_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_IN_THE_CASE_OTHER_ORDERS_EXIST_WITH_THE_SAME_PRICE_THE_QUANTITY_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_EXISTING_ORDERS_AND_QUOTES_THE_REMAINDER_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_OTHER_SIDE_OF_THE_CROSS_THE_TWO_SIDES_POTENTIALLY_HAVE_DIFFERENT_QUANTITIES",Swig_var_CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_IN_THE_CASE_OTHER_ORDERS_EXIST_WITH_THE_SAME_PRICE_THE_QUANTITY_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_EXISTING_ORDERS_AND_QUOTES_THE_REMAINDER_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_OTHER_SIDE_OF_THE_CROSS_THE_TWO_SIDES_POTENTIALLY_HAVE_DIFFERENT_QUANTITIES_get, Swig_var_CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_IN_THE_CASE_OTHER_ORDERS_EXIST_WITH_THE_SAME_PRICE_THE_QUANTITY_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_EXISTING_ORDERS_AND_QUOTES_THE_REMAINDER_OF_THE_CROSS_IS_EXECUTED_AGAINST_THE_OTHER_SIDE_OF_THE_CROSS_THE_TWO_SIDES_POTENTIALLY_HAVE_DIFFERENT_QUANTITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_AON",Swig_var_CrossType_CROSS_AON_get, Swig_var_CrossType_CROSS_AON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_TRADE_WHICH_IS_PARTIALLY_EXECUTED_WITH_THE_UNFILLED_PORTIONS_REMAINING_ACTIVE_ONE_SIDE_OF_THE_CROSS_IS_FULLY_EXECUTED",Swig_var_CrossType_CROSS_TRADE_WHICH_IS_PARTIALLY_EXECUTED_WITH_THE_UNFILLED_PORTIONS_REMAINING_ACTIVE_ONE_SIDE_OF_THE_CROSS_IS_FULLY_EXECUTED_get, Swig_var_CrossType_CROSS_TRADE_WHICH_IS_PARTIALLY_EXECUTED_WITH_THE_UNFILLED_PORTIONS_REMAINING_ACTIVE_ONE_SIDE_OF_THE_CROSS_IS_FULLY_EXECUTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_COMPLETELY_OR_NOT_BOTH_SIDES_ARE_TREATED_IN_THE_SAME_MANNER_THIS_IS_EQUIVALENT_TO_AN_ALL_OR_NONE",Swig_var_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_COMPLETELY_OR_NOT_BOTH_SIDES_ARE_TREATED_IN_THE_SAME_MANNER_THIS_IS_EQUIVALENT_TO_AN_ALL_OR_NONE_get, Swig_var_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_COMPLETELY_OR_NOT_BOTH_SIDES_ARE_TREATED_IN_THE_SAME_MANNER_THIS_IS_EQUIVALENT_TO_AN_ALL_OR_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE",Swig_var_CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_get, Swig_var_CrossType_CROSS_TRADE_IS_EXECUTED_WITH_EXISTING_ORDERS_WITH_THE_SAME_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_ONE_SIDE",Swig_var_CrossType_CROSS_ONE_SIDE_get, Swig_var_CrossType_CROSS_ONE_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_SAME_PRICE",Swig_var_CrossType_CROSS_SAME_PRICE_get, Swig_var_CrossType_CROSS_SAME_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_IOC",Swig_var_CrossType_CROSS_IOC_get, Swig_var_CrossType_CROSS_IOC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE",Swig_var_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_get, Swig_var_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_NOTE_THE_CROSSPRIORITZATION",Swig_var_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_NOTE_THE_CROSSPRIORITZATION_get, Swig_var_CrossType_CROSS_TRADE_WHICH_IS_EXECUTED_PARTIALLY_AND_THE_REST_IS_CANCELLED_ONE_SIDE_IS_FULLY_EXECUTED_THE_OTHER_SIDE_IS_PARTIALLY_EXECUTED_WITH_THE_REMAINDER_BEING_CANCELLED_THIS_IS_EQUIVALENT_TO_AN_IMMEDIATE_OR_CANCEL_ON_THE_OTHER_SIDE_NOTE_THE_CROSSPRIORITZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettleFlag_SESSION_OPEN",Swig_var_OpenCloseSettleFlag_SESSION_OPEN_get, Swig_var_OpenCloseSettleFlag_SESSION_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettleFlag_DAILY_OPEN",Swig_var_OpenCloseSettleFlag_DAILY_OPEN_get, Swig_var_OpenCloseSettleFlag_DAILY_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettleFlag_EXPECTED_PRICE",Swig_var_OpenCloseSettleFlag_EXPECTED_PRICE_get, Swig_var_OpenCloseSettleFlag_EXPECTED_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY",Swig_var_OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY_get, Swig_var_OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE",Swig_var_OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE_get, Swig_var_OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDBookType_PRICE_DEPTH",Swig_var_MDBookType_PRICE_DEPTH_get, Swig_var_MDBookType_PRICE_DEPTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDBookType_ORDER_DEPTH",Swig_var_MDBookType_ORDER_DEPTH_get, Swig_var_MDBookType_ORDER_DEPTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDBookType_TOP_OF_BOOK",Swig_var_MDBookType_TOP_OF_BOOK_get, Swig_var_MDBookType_TOP_OF_BOOK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI",Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI_get, Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAP_THROUGH_A_MORNING_SESSION",Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_get, Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_CLOSING_PRICE",Swig_var_BasisPxType_CLOSING_PRICE_get, Swig_var_BasisPxType_CLOSING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAP_THROUGH_A_DAY",Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_get, Swig_var_BasisPxType_VWAP_THROUGH_A_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_OTHERS",Swig_var_BasisPxType_OTHERS_get, Swig_var_BasisPxType_OTHERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_OPEN",Swig_var_BasisPxType_OPEN_get, Swig_var_BasisPxType_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION",Swig_var_BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION_get, Swig_var_BasisPxType_CLOSING_PRICE_AT_MORNING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_CURRENT_PRICE",Swig_var_BasisPxType_CURRENT_PRICE_get, Swig_var_BasisPxType_CURRENT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_SQ",Swig_var_BasisPxType_SQ_get, Swig_var_BasisPxType_SQ_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_STRIKE",Swig_var_BasisPxType_STRIKE_get, Swig_var_BasisPxType_STRIKE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI",Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI_get, Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI",Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI_get, Swig_var_BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION",Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_get, Swig_var_BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_ROLLING_BARRIER",Swig_var_ComplexEventType_ROLLING_BARRIER_get, Swig_var_ComplexEventType_ROLLING_BARRIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_UNDERLYING",Swig_var_ComplexEventType_UNDERLYING_get, Swig_var_ComplexEventType_UNDERLYING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_KNOCK_OUT_UP",Swig_var_ComplexEventType_KNOCK_OUT_UP_get, Swig_var_ComplexEventType_KNOCK_OUT_UP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_KNOCK_IN_UP",Swig_var_ComplexEventType_KNOCK_IN_UP_get, Swig_var_ComplexEventType_KNOCK_IN_UP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_KOCK_IN_DOWN",Swig_var_ComplexEventType_KOCK_IN_DOWN_get, Swig_var_ComplexEventType_KOCK_IN_DOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_TRIGGER",Swig_var_ComplexEventType_TRIGGER_get, Swig_var_ComplexEventType_TRIGGER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_RESET_BARRIER",Swig_var_ComplexEventType_RESET_BARRIER_get, Swig_var_ComplexEventType_RESET_BARRIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_CAPPED",Swig_var_ComplexEventType_CAPPED_get, Swig_var_ComplexEventType_CAPPED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventType_KNOCK_OUT_DOWN",Swig_var_ComplexEventType_KNOCK_OUT_DOWN_get, Swig_var_ComplexEventType_KNOCK_OUT_DOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionResponse_REJECTED",Swig_var_MassActionResponse_REJECTED_get, Swig_var_MassActionResponse_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassActionResponse_ACCEPTED",Swig_var_MassActionResponse_ACCEPTED_get, Swig_var_MassActionResponse_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID",Swig_var_SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_get, Swig_var_SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_REQUEST_LIST_SECURITY_TYPES",Swig_var_SecurityRequestType_REQUEST_LIST_SECURITY_TYPES_get, Swig_var_SecurityRequestType_REQUEST_LIST_SECURITY_TYPES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_REQUEST_LIST_SECURITIES",Swig_var_SecurityRequestType_REQUEST_LIST_SECURITIES_get, Swig_var_SecurityRequestType_REQUEST_LIST_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_SYMBOL",Swig_var_SecurityRequestType_SYMBOL_get, Swig_var_SecurityRequestType_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE",Swig_var_SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE_get, Swig_var_SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED",Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED_get, Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_TRADINGSESSIONID",Swig_var_SecurityRequestType_TRADINGSESSIONID_get, Swig_var_SecurityRequestType_TRADINGSESSIONID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_PRODUCT",Swig_var_SecurityRequestType_PRODUCT_get, Swig_var_SecurityRequestType_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_ALL_SECURITIES",Swig_var_SecurityRequestType_ALL_SECURITIES_get, Swig_var_SecurityRequestType_ALL_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS",Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS_get, Swig_var_SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListRejectReason_EXCHANGE_CLOSED",Swig_var_ListRejectReason_EXCHANGE_CLOSED_get, Swig_var_ListRejectReason_EXCHANGE_CLOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListRejectReason_UNKNOWN_ORDER",Swig_var_ListRejectReason_UNKNOWN_ORDER_get, Swig_var_ListRejectReason_UNKNOWN_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC",Swig_var_ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC_get, Swig_var_ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListRejectReason_DUPLICATE_ORDER",Swig_var_ListRejectReason_DUPLICATE_ORDER_get, Swig_var_ListRejectReason_DUPLICATE_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListRejectReason_TOO_LATE_TO_ENTER",Swig_var_ListRejectReason_TOO_LATE_TO_ENTER_get, Swig_var_ListRejectReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListRejectReason_OTHER",Swig_var_ListRejectReason_OTHER_get, Swig_var_ListRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListRejectReason_BROKER",Swig_var_ListRejectReason_BROKER_get, Swig_var_ListRejectReason_BROKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_PROPRIETARY",Swig_var_DeskType_PROPRIETARY_get, Swig_var_DeskType_PROPRIETARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_ARBITRAGE",Swig_var_DeskType_ARBITRAGE_get, Swig_var_DeskType_ARBITRAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_TRADING",Swig_var_DeskType_TRADING_get, Swig_var_DeskType_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_DERIVATIVES",Swig_var_DeskType_DERIVATIVES_get, Swig_var_DeskType_DERIVATIVES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_SALES",Swig_var_DeskType_SALES_get, Swig_var_DeskType_SALES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_INSTITUTIONAL",Swig_var_DeskType_INSTITUTIONAL_get, Swig_var_DeskType_INSTITUTIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_INTERNATIONAL",Swig_var_DeskType_INTERNATIONAL_get, Swig_var_DeskType_INTERNATIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_AGENCY",Swig_var_DeskType_AGENCY_get, Swig_var_DeskType_AGENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_PREFERRED_TRADING",Swig_var_DeskType_PREFERRED_TRADING_get, Swig_var_DeskType_PREFERRED_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_OTHER",Swig_var_DeskType_OTHER_get, Swig_var_DeskType_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskType_PROGRAM_TRADING",Swig_var_DeskType_PROGRAM_TRADING_get, Swig_var_DeskType_PROGRAM_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_WHEN_AND_IF_ISSUED",Swig_var_SettlType_WHEN_AND_IF_ISSUED_get, Swig_var_SettlType_WHEN_AND_IF_ISSUED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_FUTURE",Swig_var_SettlType_FUTURE_get, Swig_var_SettlType_FUTURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_BROKEN_DATE",Swig_var_SettlType_BROKEN_DATE_get, Swig_var_SettlType_BROKEN_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_SELLERS_OPTION",Swig_var_SettlType_SELLERS_OPTION_get, Swig_var_SettlType_SELLERS_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_T_PLUS_2",Swig_var_SettlType_T_PLUS_2_get, Swig_var_SettlType_T_PLUS_2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_T_PLUS_3",Swig_var_SettlType_T_PLUS_3_get, Swig_var_SettlType_T_PLUS_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_T_PLUS_4",Swig_var_SettlType_T_PLUS_4_get, Swig_var_SettlType_T_PLUS_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_REGULAR",Swig_var_SettlType_REGULAR_get, Swig_var_SettlType_REGULAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_FX_SPOT_NEXT_SETTLEMENT",Swig_var_SettlType_FX_SPOT_NEXT_SETTLEMENT_get, Swig_var_SettlType_FX_SPOT_NEXT_SETTLEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_T_PLUS_5",Swig_var_SettlType_T_PLUS_5_get, Swig_var_SettlType_T_PLUS_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_NEXT_DAY",Swig_var_SettlType_NEXT_DAY_get, Swig_var_SettlType_NEXT_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlType_CASH",Swig_var_SettlType_CASH_get, Swig_var_SettlType_CASH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenClose_CLOSE",Swig_var_OpenClose_CLOSE_get, Swig_var_OpenClose_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OpenClose_OPEN",Swig_var_OpenClose_OPEN_get, Swig_var_OpenClose_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContractMultiplierUnit_SHARES",Swig_var_ContractMultiplierUnit_SHARES_get, Swig_var_ContractMultiplierUnit_SHARES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContractMultiplierUnit_HOURS",Swig_var_ContractMultiplierUnit_HOURS_get, Swig_var_ContractMultiplierUnit_HOURS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ContractMultiplierUnit_DAYS",Swig_var_ContractMultiplierUnit_DAYS_get, Swig_var_ContractMultiplierUnit_DAYS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE",Swig_var_TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE_get, Swig_var_TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_FUTURES_LARGE_ORDER_EXECUTION",Swig_var_TrdType_FUTURES_LARGE_ORDER_EXECUTION_get, Swig_var_TrdType_FUTURES_LARGE_ORDER_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES",Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES_get, Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS",Swig_var_TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS_get, Swig_var_TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_BLOCK_TRADE_38",Swig_var_TrdType_BLOCK_TRADE_38_get, Swig_var_TrdType_BLOCK_TRADE_38_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_DELTA_NEUTRAL_TRANSACTION",Swig_var_TrdType_DELTA_NEUTRAL_TRANSACTION_get, Swig_var_TrdType_DELTA_NEUTRAL_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_LATE_TRADE",Swig_var_TrdType_LATE_TRADE_get, Swig_var_TrdType_LATE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_CASH_SETTLEMENT",Swig_var_TrdType_CASH_SETTLEMENT_get, Swig_var_TrdType_CASH_SETTLEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS",Swig_var_TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS_get, Swig_var_TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_CUM_BONUS",Swig_var_TrdType_SPECIAL_CUM_BONUS_get, Swig_var_TrdType_SPECIAL_CUM_BONUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_BLOCK_TRADES",Swig_var_TrdType_BLOCK_TRADES_get, Swig_var_TrdType_BLOCK_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_ALL_OR_NONE",Swig_var_TrdType_ALL_OR_NONE_get, Swig_var_TrdType_ALL_OR_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_OPTION_EXERCISE",Swig_var_TrdType_OPTION_EXERCISE_get, Swig_var_TrdType_OPTION_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_FINANCING_TRANSACTION",Swig_var_TrdType_FINANCING_TRANSACTION_get, Swig_var_TrdType_FINANCING_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_TRANSFER",Swig_var_TrdType_TRANSFER_get, Swig_var_TrdType_TRANSFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_TRADING_AT_SETTLEMENT",Swig_var_TrdType_TRADING_AT_SETTLEMENT_get, Swig_var_TrdType_TRADING_AT_SETTLEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_EX_DIVIDEND",Swig_var_TrdType_SPECIAL_EX_DIVIDEND_get, Swig_var_TrdType_SPECIAL_EX_DIVIDEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_EX_COUPON",Swig_var_TrdType_SPECIAL_EX_COUPON_get, Swig_var_TrdType_SPECIAL_EX_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_PRICE",Swig_var_TrdType_SPECIAL_PRICE_get, Swig_var_TrdType_SPECIAL_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_CUM_RIGHTS",Swig_var_TrdType_SPECIAL_CUM_RIGHTS_get, Swig_var_TrdType_SPECIAL_CUM_RIGHTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_EX_BONUS",Swig_var_TrdType_SPECIAL_EX_BONUS_get, Swig_var_TrdType_SPECIAL_EX_BONUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_REGULAR_TRADE",Swig_var_TrdType_REGULAR_TRADE_get, Swig_var_TrdType_REGULAR_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EXCHANGE_GRANTED_TRADE",Swig_var_TrdType_EXCHANGE_GRANTED_TRADE_get, Swig_var_TrdType_EXCHANGE_GRANTED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EXCHANGE_BASIS_FACILITY",Swig_var_TrdType_EXCHANGE_BASIS_FACILITY_get, Swig_var_TrdType_EXCHANGE_BASIS_FACILITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_BLOCK_TRADE_1",Swig_var_TrdType_BLOCK_TRADE_1_get, Swig_var_TrdType_BLOCK_TRADE_1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_ERROR_TRADE",Swig_var_TrdType_ERROR_TRADE_get, Swig_var_TrdType_ERROR_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_NAME_CHANGE",Swig_var_TrdType_NAME_CHANGE_get, Swig_var_TrdType_NAME_CHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_LATE_BUNCHED_TRADE",Swig_var_TrdType_LATE_BUNCHED_TRADE_get, Swig_var_TrdType_LATE_BUNCHED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EFP",Swig_var_TrdType_EFP_get, Swig_var_TrdType_EFP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_NON_STANDARD_SETTLEMENT",Swig_var_TrdType_NON_STANDARD_SETTLEMENT_get, Swig_var_TrdType_NON_STANDARD_SETTLEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EXCHANGE_FOR_RISK",Swig_var_TrdType_EXCHANGE_FOR_RISK_get, Swig_var_TrdType_EXCHANGE_FOR_RISK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EXCHANGE_FOR_SWAP",Swig_var_TrdType_EXCHANGE_FOR_SWAP_get, Swig_var_TrdType_EXCHANGE_FOR_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EXCHANGE_OF_FUTURES_FOR",Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_get, Swig_var_TrdType_EXCHANGE_OF_FUTURES_FOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_OPTION_INTERIM_TRADE",Swig_var_TrdType_OPTION_INTERIM_TRADE_get, Swig_var_TrdType_OPTION_INTERIM_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_PRIVATELY_NEGOTIATED_TRADES",Swig_var_TrdType_PRIVATELY_NEGOTIATED_TRADES_get, Swig_var_TrdType_PRIVATELY_NEGOTIATED_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS",Swig_var_TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS_get, Swig_var_TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_CUM_DIVIDEND",Swig_var_TrdType_SPECIAL_CUM_DIVIDEND_get, Swig_var_TrdType_SPECIAL_CUM_DIVIDEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_GUARANTEED_DELIVERY",Swig_var_TrdType_GUARANTEED_DELIVERY_get, Swig_var_TrdType_GUARANTEED_DELIVERY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_PROROGATION_SELL",Swig_var_TrdType_PROROGATION_SELL_get, Swig_var_TrdType_PROROGATION_SELL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_PRIOR_REFERENCE_PRICE_TRADE",Swig_var_TrdType_PRIOR_REFERENCE_PRICE_TRADE_get, Swig_var_TrdType_PRIOR_REFERENCE_PRICE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_PORTFOLIO_TRADE",Swig_var_TrdType_PORTFOLIO_TRADE_get, Swig_var_TrdType_PORTFOLIO_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_WORKED_PRINCIPAL_TRADE",Swig_var_TrdType_WORKED_PRINCIPAL_TRADE_get, Swig_var_TrdType_WORKED_PRINCIPAL_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_PORTFOLIO_TRANSFER",Swig_var_TrdType_PORTFOLIO_TRANSFER_get, Swig_var_TrdType_PORTFOLIO_TRANSFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_WEIGHTED_AVERAGE_PRICE_TRADE",Swig_var_TrdType_WEIGHTED_AVERAGE_PRICE_TRADE_get, Swig_var_TrdType_WEIGHTED_AVERAGE_PRICE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS",Swig_var_TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS_get, Swig_var_TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_CUM_COUPON",Swig_var_TrdType_SPECIAL_CUM_COUPON_get, Swig_var_TrdType_SPECIAL_CUM_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_T_TRADE",Swig_var_TrdType_T_TRADE_get, Swig_var_TrdType_T_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_BLOCK_TRADE",Swig_var_TrdType_BLOCK_TRADE_get, Swig_var_TrdType_BLOCK_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_OTC",Swig_var_TrdType_OTC_get, Swig_var_TrdType_OTC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_AFTER_HOURS_TRADE",Swig_var_TrdType_AFTER_HOURS_TRADE_get, Swig_var_TrdType_AFTER_HOURS_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_DERIVATIVE_RELATED_TRANSACTION",Swig_var_TrdType_DERIVATIVE_RELATED_TRANSACTION_get, Swig_var_TrdType_DERIVATIVE_RELATED_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_REPURCHASE_AGREEMENT",Swig_var_TrdType_REPURCHASE_AGREEMENT_get, Swig_var_TrdType_REPURCHASE_AGREEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_SPECIAL_EX_RIGHTS",Swig_var_TrdType_SPECIAL_EX_RIGHTS_get, Swig_var_TrdType_SPECIAL_EX_RIGHTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_PROROGATION_BUY",Swig_var_TrdType_PROROGATION_BUY_get, Swig_var_TrdType_PROROGATION_BUY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_OPTION_CABINET_TRADE",Swig_var_TrdType_OPTION_CABINET_TRADE_get, Swig_var_TrdType_OPTION_CABINET_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdType_BUNCHED_TRADE",Swig_var_TrdType_BUNCHED_TRADE_get, Swig_var_TrdType_BUNCHED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RestructuringType_MODIFIED_MOD_RESTRUCTURING",Swig_var_RestructuringType_MODIFIED_MOD_RESTRUCTURING_get, Swig_var_RestructuringType_MODIFIED_MOD_RESTRUCTURING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RestructuringType_FULL_RESTRUCTURING",Swig_var_RestructuringType_FULL_RESTRUCTURING_get, Swig_var_RestructuringType_FULL_RESTRUCTURING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RestructuringType_NO_RESTRUCTURING_SPECIFIED",Swig_var_RestructuringType_NO_RESTRUCTURING_SPECIFIED_get, Swig_var_RestructuringType_NO_RESTRUCTURING_SPECIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RestructuringType_MODIFIED_RESTRUCTURING",Swig_var_RestructuringType_MODIFIED_RESTRUCTURING_get, Swig_var_RestructuringType_MODIFIED_RESTRUCTURING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProgRptReqs_REAL_TIME_EXECUTION_REPORTS",Swig_var_ProgRptReqs_REAL_TIME_EXECUTION_REPORTS_get, Swig_var_ProgRptReqs_REAL_TIME_EXECUTION_REPORTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProgRptReqs_BUYSIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUSREQUEST",Swig_var_ProgRptReqs_BUYSIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUSREQUEST_get, Swig_var_ProgRptReqs_BUYSIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUSREQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProgRptReqs_SELL_SIDE_PERIODICALLY_SENDS_STATUS_USING_LIST_STATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD",Swig_var_ProgRptReqs_SELL_SIDE_PERIODICALLY_SENDS_STATUS_USING_LIST_STATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_get, Swig_var_ProgRptReqs_SELL_SIDE_PERIODICALLY_SENDS_STATUS_USING_LIST_STATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST",Swig_var_ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST_get, Swig_var_ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD",Swig_var_ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_get, Swig_var_ProgRptReqs_SELLSIDE_PERIODICALLY_SENDS_STATUS_USING_LISTSTATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionID_EVENING",Swig_var_TradingSessionID_EVENING_get, Swig_var_TradingSessionID_EVENING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionID_AFTER_HOURS",Swig_var_TradingSessionID_AFTER_HOURS_get, Swig_var_TradingSessionID_AFTER_HOURS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionID_HALFDAY",Swig_var_TradingSessionID_HALFDAY_get, Swig_var_TradingSessionID_HALFDAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionID_DAY",Swig_var_TradingSessionID_DAY_get, Swig_var_TradingSessionID_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionID_MORNING",Swig_var_TradingSessionID_MORNING_get, Swig_var_TradingSessionID_MORNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradingSessionID_AFTERNOON",Swig_var_TradingSessionID_AFTERNOON_get, Swig_var_TradingSessionID_AFTERNOON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_CANCELING",Swig_var_ListOrderStatus_CANCELING_get, Swig_var_ListOrderStatus_CANCELING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_REJECT",Swig_var_ListOrderStatus_REJECT_get, Swig_var_ListOrderStatus_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_ALL_DONE",Swig_var_ListOrderStatus_ALL_DONE_get, Swig_var_ListOrderStatus_ALL_DONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_IN_BIDDING_PROCESS",Swig_var_ListOrderStatus_IN_BIDDING_PROCESS_get, Swig_var_ListOrderStatus_IN_BIDDING_PROCESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_RECEIVED_FOR_EXECUTION",Swig_var_ListOrderStatus_RECEIVED_FOR_EXECUTION_get, Swig_var_ListOrderStatus_RECEIVED_FOR_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_ALERT",Swig_var_ListOrderStatus_ALERT_get, Swig_var_ListOrderStatus_ALERT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_RECEIVEDFOREXECUTION",Swig_var_ListOrderStatus_RECEIVEDFOREXECUTION_get, Swig_var_ListOrderStatus_RECEIVEDFOREXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_INBIDDINGPROCESS",Swig_var_ListOrderStatus_INBIDDINGPROCESS_get, Swig_var_ListOrderStatus_INBIDDINGPROCESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_CANCELLING",Swig_var_ListOrderStatus_CANCELLING_get, Swig_var_ListOrderStatus_CANCELLING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListOrderStatus_EXECUTING",Swig_var_ListOrderStatus_EXECUTING_get, Swig_var_ListOrderStatus_EXECUTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistStatus_REJECT",Swig_var_RegistStatus_REJECT_get, Swig_var_RegistStatus_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING",Swig_var_RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING_get, Swig_var_RegistStatus_REMINDER_IE_REGISTRATION_INSTRUCTIONS_ARE_STILL_OUTSTANDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistStatus_REJECTED",Swig_var_RegistStatus_REJECTED_get, Swig_var_RegistStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistStatus_ACCEPTED",Swig_var_RegistStatus_ACCEPTED_get, Swig_var_RegistStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistStatus_REMINDER",Swig_var_RegistStatus_REMINDER_get, Swig_var_RegistStatus_REMINDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistStatus_HELD",Swig_var_RegistStatus_HELD_get, Swig_var_RegistStatus_HELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistStatus_ACCEPT",Swig_var_RegistStatus_ACCEPT_get, Swig_var_RegistStatus_ACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE",Swig_var_UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_get, Swig_var_UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE",Swig_var_UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_get, Swig_var_UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingPriceDeterminationMethod_AVERAGE_VALUE",Swig_var_UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_get, Swig_var_UnderlyingPriceDeterminationMethod_AVERAGE_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingPriceDeterminationMethod_REGULAR",Swig_var_UnderlyingPriceDeterminationMethod_REGULAR_get, Swig_var_UnderlyingPriceDeterminationMethod_REGULAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY",Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP",Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET",Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT",Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE",Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION",Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY",Swig_var_MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY",Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ALL_ORDERS",Swig_var_MassCancelRequestType_CANCEL_ALL_ORDERS_get, Swig_var_MassCancelRequestType_CANCEL_ALL_ORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER",Swig_var_MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER_get, Swig_var_MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT",Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE",Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE_get, Swig_var_MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejResponseTo_ORDER_CANCEL_REQUEST",Swig_var_CxlRejResponseTo_ORDER_CANCEL_REQUEST_get, Swig_var_CxlRejResponseTo_ORDER_CANCEL_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST",Swig_var_CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST_get, Swig_var_CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_BY_QUOTETYPE",Swig_var_QuoteCancelType_CANCEL_BY_QUOTETYPE_get, Swig_var_QuoteCancelType_CANCEL_BY_QUOTETYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES",Swig_var_QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES_get, Swig_var_QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID",Swig_var_QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID_get, Swig_var_QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL",Swig_var_QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL_get, Swig_var_QuoteCancelType_CANCEL_FOR_UNDERLYING_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_ALL_QUOTES",Swig_var_QuoteCancelType_CANCEL_ALL_QUOTES_get, Swig_var_QuoteCancelType_CANCEL_ALL_QUOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY",Swig_var_QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY_get, Swig_var_QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY",Swig_var_QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_get, Swig_var_QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER",Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER_get, Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_ALL_QUOTES",Swig_var_QuoteCancelType_CANCEL_FOR_ALL_QUOTES_get, Swig_var_QuoteCancelType_CANCEL_FOR_ALL_QUOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_SECURITY_TYPE",Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_TYPE_get, Swig_var_QuoteCancelType_CANCEL_FOR_SECURITY_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCancelType_CANCEL_FOR_SYMBOL",Swig_var_QuoteCancelType_CANCEL_FOR_SYMBOL_get, Swig_var_QuoteCancelType_CANCEL_FOR_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_YIELD_TO_MATURITY",Swig_var_StipulationType_YIELD_TO_MATURITY_get, Swig_var_StipulationType_YIELD_TO_MATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ALTERNATIVE_MINIMUM_TAX",Swig_var_StipulationType_ALTERNATIVE_MINIMUM_TAX_get, Swig_var_StipulationType_ALTERNATIVE_MINIMUM_TAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_VALUE_IN_PERCENT",Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_VALUE_IN_PERCENT_get, Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_VALUE_IN_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_GEOGRAPHICS_AND_RANGE",Swig_var_StipulationType_GEOGRAPHICS_AND_RANGE_get, Swig_var_StipulationType_GEOGRAPHICS_AND_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_COUPON_RANGE",Swig_var_StipulationType_COUPON_RANGE_get, Swig_var_StipulationType_COUPON_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_BANK_QUALIFIED",Swig_var_StipulationType_BANK_QUALIFIED_get, Swig_var_StipulationType_BANK_QUALIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_RATING_SOURCE_AND_RANGE",Swig_var_StipulationType_RATING_SOURCE_AND_RANGE_get, Swig_var_StipulationType_RATING_SOURCE_AND_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_SUBSTITUTIONS_FREQUENCY",Swig_var_StipulationType_SUBSTITUTIONS_FREQUENCY_get, Swig_var_StipulationType_SUBSTITUTIONS_FREQUENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MINIMUM_DENOMINATION",Swig_var_StipulationType_MINIMUM_DENOMINATION_get, Swig_var_StipulationType_MINIMUM_DENOMINATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET",Swig_var_StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET_get, Swig_var_StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MAXIMUM_ORDER_SIZE",Swig_var_StipulationType_MAXIMUM_ORDER_SIZE_get, Swig_var_StipulationType_MAXIMUM_ORDER_SIZE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ABSOLUTE_PREPAYMENT_SPEED",Swig_var_StipulationType_ABSOLUTE_PREPAYMENT_SPEED_get, Swig_var_StipulationType_ABSOLUTE_PREPAYMENT_SPEED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PRICING_FREQUENCY",Swig_var_StipulationType_PRICING_FREQUENCY_get, Swig_var_StipulationType_PRICING_FREQUENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CONSTANT_PREPAYMENT_YIELD",Swig_var_StipulationType_CONSTANT_PREPAYMENT_YIELD_get, Swig_var_StipulationType_CONSTANT_PREPAYMENT_YIELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_YIELD_RANGE",Swig_var_StipulationType_YIELD_RANGE_get, Swig_var_StipulationType_YIELD_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE",Swig_var_StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE_get, Swig_var_StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_BENCHMARK_PRICE_SOURCE",Swig_var_StipulationType_BENCHMARK_PRICE_SOURCE_get, Swig_var_StipulationType_BENCHMARK_PRICE_SOURCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MAXIMUM_SUBSTITUTIONS",Swig_var_StipulationType_MAXIMUM_SUBSTITUTIONS_get, Swig_var_StipulationType_MAXIMUM_SUBSTITUTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE",Swig_var_StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE_get, Swig_var_StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MONTHLY_PREPAYMENT_RATE",Swig_var_StipulationType_MONTHLY_PREPAYMENT_RATE_get, Swig_var_StipulationType_MONTHLY_PREPAYMENT_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PURPOSE",Swig_var_StipulationType_PURPOSE_get, Swig_var_StipulationType_PURPOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WHOLE_POOL",Swig_var_StipulationType_WHOLE_POOL_get, Swig_var_StipulationType_WHOLE_POOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTED_AVERAGE_LOAN_AGE",Swig_var_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_get, Swig_var_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON",Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_get, Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOLS_MAXIMUM",Swig_var_StipulationType_POOLS_MAXIMUM_get, Swig_var_StipulationType_POOLS_MAXIMUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MINIMUM_QUANTITY",Swig_var_StipulationType_MINIMUM_QUANTITY_get, Swig_var_StipulationType_MINIMUM_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE",Swig_var_StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE_get, Swig_var_StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_VALUATION_DISCOUNT",Swig_var_StipulationType_VALUATION_DISCOUNT_get, Swig_var_StipulationType_VALUATION_DISCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_GEOGRAPHICS",Swig_var_StipulationType_GEOGRAPHICS_get, Swig_var_StipulationType_GEOGRAPHICS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_AMT",Swig_var_StipulationType_AMT_get, Swig_var_StipulationType_AMT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTED_AVERAGE_MATURITY",Swig_var_StipulationType_WEIGHTED_AVERAGE_MATURITY_get, Swig_var_StipulationType_WEIGHTED_AVERAGE_MATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CALL_PROTECTION",Swig_var_StipulationType_CALL_PROTECTION_get, Swig_var_StipulationType_CALL_PROTECTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_EXPLICIT_LOT_IDENTIFIER",Swig_var_StipulationType_EXPLICIT_LOT_IDENTIFIER_get, Swig_var_StipulationType_EXPLICIT_LOT_IDENTIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_FREEFORM_TEXT",Swig_var_StipulationType_FREEFORM_TEXT_get, Swig_var_StipulationType_FREEFORM_TEXT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_TRADE_VARIANCE",Swig_var_StipulationType_TRADE_VARIANCE_get, Swig_var_StipulationType_TRADE_VARIANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTED_AVERAGE_COUPONVALUE_IN_PERCENT",Swig_var_StipulationType_WEIGHTED_AVERAGE_COUPONVALUE_IN_PERCENT_get, Swig_var_StipulationType_WEIGHTED_AVERAGE_COUPONVALUE_IN_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS",Swig_var_StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get, Swig_var_StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_STRUCTURE",Swig_var_StipulationType_STRUCTURE_get, Swig_var_StipulationType_STRUCTURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_RESTRICTED",Swig_var_StipulationType_RESTRICTED_get, Swig_var_StipulationType_RESTRICTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CONSTANT_PREPAYMENT_PENALTY",Swig_var_StipulationType_CONSTANT_PREPAYMENT_PENALTY_get, Swig_var_StipulationType_CONSTANT_PREPAYMENT_PENALTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS",Swig_var_StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS_get, Swig_var_StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE",Swig_var_StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE_get, Swig_var_StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE",Swig_var_StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_get, Swig_var_StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_TYPE_OF_REDEMPTION",Swig_var_StipulationType_TYPE_OF_REDEMPTION_get, Swig_var_StipulationType_TYPE_OF_REDEMPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_SECURITYTYPE_INCLUDED_OR_EXCLUDED",Swig_var_StipulationType_SECURITYTYPE_INCLUDED_OR_EXCLUDED_get, Swig_var_StipulationType_SECURITYTYPE_INCLUDED_OR_EXCLUDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PAYMENT_FREQUENCY_CALENDAR",Swig_var_StipulationType_PAYMENT_FREQUENCY_CALENDAR_get, Swig_var_StipulationType_PAYMENT_FREQUENCY_CALENDAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER",Swig_var_StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER_get, Swig_var_StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ISSUERS_TICKER",Swig_var_StipulationType_ISSUERS_TICKER_get, Swig_var_StipulationType_ISSUERS_TICKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MAXIMUM_LOAN_BALANCE",Swig_var_StipulationType_MAXIMUM_LOAN_BALANCE_get, Swig_var_StipulationType_MAXIMUM_LOAN_BALANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_BROKER_SALES_CREDIT_OVERRIDE",Swig_var_StipulationType_BROKER_SALES_CREDIT_OVERRIDE_get, Swig_var_StipulationType_BROKER_SALES_CREDIT_OVERRIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_OF_BMA_PREPAYMENT_CURVE",Swig_var_StipulationType_OF_BMA_PREPAYMENT_CURVE_get, Swig_var_StipulationType_OF_BMA_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ISO_CURRENCY_CODE",Swig_var_StipulationType_ISO_CURRENCY_CODE_get, Swig_var_StipulationType_ISO_CURRENCY_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MARKET_SECTOR",Swig_var_StipulationType_MARKET_SECTOR_get, Swig_var_StipulationType_MARKET_SECTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOL_IDENTIFIER",Swig_var_StipulationType_POOL_IDENTIFIER_get, Swig_var_StipulationType_POOL_IDENTIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_TYPE_OF_ROLL_TRADE",Swig_var_StipulationType_TYPE_OF_ROLL_TRADE_get, Swig_var_StipulationType_TYPE_OF_ROLL_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED",Swig_var_StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED_get, Swig_var_StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_YEAR_OF_ISSUE",Swig_var_StipulationType_YEAR_OF_ISSUE_get, Swig_var_StipulationType_YEAR_OF_ISSUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_LOOKBACK_DAYS",Swig_var_StipulationType_LOOKBACK_DAYS_get, Swig_var_StipulationType_LOOKBACK_DAYS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_TYPE_OF_REDEMPTION_VALUES_ARE_NONCALLABLE_CALLABLE_PREFUNDED_ESCROWEDTOMATURITY_PUTABLE_CONVERTIBLE",Swig_var_StipulationType_TYPE_OF_REDEMPTION_VALUES_ARE_NONCALLABLE_CALLABLE_PREFUNDED_ESCROWEDTOMATURITY_PUTABLE_CONVERTIBLE_get, Swig_var_StipulationType_TYPE_OF_REDEMPTION_VALUES_ARE_NONCALLABLE_CALLABLE_PREFUNDED_ESCROWEDTOMATURITY_PUTABLE_CONVERTIBLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MATURITY_YEAR",Swig_var_StipulationType_MATURITY_YEAR_get, Swig_var_StipulationType_MATURITY_YEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CUSTOM_START_END_DATE",Swig_var_StipulationType_CUSTOM_START_END_DATE_get, Swig_var_StipulationType_CUSTOM_START_END_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ORDER_QUANTITY_INCREMENT",Swig_var_StipulationType_ORDER_QUANTITY_INCREMENT_get, Swig_var_StipulationType_ORDER_QUANTITY_INCREMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_DISCOUNT_RATE",Swig_var_StipulationType_DISCOUNT_RATE_get, Swig_var_StipulationType_DISCOUNT_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE",Swig_var_StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE_get, Swig_var_StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_CONSTANT_PREPAYMENT_RATE",Swig_var_StipulationType_CONSTANT_PREPAYMENT_RATE_get, Swig_var_StipulationType_CONSTANT_PREPAYMENT_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE",Swig_var_StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE_get, Swig_var_StipulationType_OF_PROSPECTUS_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_AVERAGE_LOAN_SIZE",Swig_var_StipulationType_AVERAGE_LOAN_SIZE_get, Swig_var_StipulationType_AVERAGE_LOAN_SIZE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_TRADERS_CREDIT",Swig_var_StipulationType_TRADERS_CREDIT_get, Swig_var_StipulationType_TRADERS_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOLS_PER_LOT",Swig_var_StipulationType_POOLS_PER_LOT_get, Swig_var_StipulationType_POOLS_PER_LOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTED_AVERAGE_LIFE",Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_get, Swig_var_StipulationType_WEIGHTED_AVERAGE_LIFE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MATURITY_RANGE",Swig_var_StipulationType_MATURITY_RANGE_get, Swig_var_StipulationType_MATURITY_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOLS_PER_MILLION",Swig_var_StipulationType_POOLS_PER_MILLION_get, Swig_var_StipulationType_POOLS_PER_MILLION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_LOT_VARIANCE",Swig_var_StipulationType_LOT_VARIANCE_get, Swig_var_StipulationType_LOT_VARIANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR",Swig_var_StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR_get, Swig_var_StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_AVERAGE_FICO_SCORE",Swig_var_StipulationType_AVERAGE_FICO_SCORE_get, Swig_var_StipulationType_AVERAGE_FICO_SCORE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTED_AVERAGE_MATURITY_VALUE_IN_MONTHS",Swig_var_StipulationType_WEIGHTED_AVERAGE_MATURITY_VALUE_IN_MONTHS_get, Swig_var_StipulationType_WEIGHTED_AVERAGE_MATURITY_VALUE_IN_MONTHS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PRICE_RANGE",Swig_var_StipulationType_PRICE_RANGE_get, Swig_var_StipulationType_PRICE_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MATURITY_YEAR_AND_MONTH",Swig_var_StipulationType_MATURITY_YEAR_AND_MONTH_get, Swig_var_StipulationType_MATURITY_YEAR_AND_MONTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_MINIMUM_INCREMENT",Swig_var_StipulationType_MINIMUM_INCREMENT_get, Swig_var_StipulationType_MINIMUM_INCREMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTED_AVERAGE_COUPON",Swig_var_StipulationType_WEIGHTED_AVERAGE_COUPON_get, Swig_var_StipulationType_WEIGHTED_AVERAGE_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE",Swig_var_StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE_get, Swig_var_StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_SUBSTITUTIONS_LEFT",Swig_var_StipulationType_SUBSTITUTIONS_LEFT_get, Swig_var_StipulationType_SUBSTITUTIONS_LEFT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_NUMBER_OF_PIECES",Swig_var_StipulationType_NUMBER_OF_PIECES_get, Swig_var_StipulationType_NUMBER_OF_PIECES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_INSURED",Swig_var_StipulationType_INSURED_get, Swig_var_StipulationType_INSURED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE",Swig_var_StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_get, Swig_var_StipulationType_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY",Swig_var_StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY_get, Swig_var_StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_BARGAIN_CONDITIONS",Swig_var_StipulationType_BARGAIN_CONDITIONS_get, Swig_var_StipulationType_BARGAIN_CONDITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_POOLS_PER_TRADE",Swig_var_StipulationType_POOLS_PER_TRADE_get, Swig_var_StipulationType_POOLS_PER_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_VALUE_IN_MONTHS",Swig_var_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_VALUE_IN_MONTHS_get, Swig_var_StipulationType_WEIGHTED_AVERAGE_LOAN_AGE_VALUE_IN_MONTHS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_SINGLE_MONTHLY_MORTALITY",Swig_var_StipulationType_SINGLE_MONTHLY_MORTALITY_get, Swig_var_StipulationType_SINGLE_MONTHLY_MORTALITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE",Swig_var_StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE_get, Swig_var_StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_BROKERS_SALES_CREDIT",Swig_var_StipulationType_BROKERS_SALES_CREDIT_get, Swig_var_StipulationType_BROKERS_SALES_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_ISSUE_SIZE_RANGE",Swig_var_StipulationType_ISSUE_SIZE_RANGE_get, Swig_var_StipulationType_ISSUE_SIZE_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_BARGAIN_CONDITIONS_SEE",Swig_var_StipulationType_BARGAIN_CONDITIONS_SEE_get, Swig_var_StipulationType_BARGAIN_CONDITIONS_SEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StipulationType_PRODUCTION_YEAR",Swig_var_StipulationType_PRODUCTION_YEAR_get, Swig_var_StipulationType_PRODUCTION_YEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceQuoteMethod_PERCENT_OF_PAR",Swig_var_PriceQuoteMethod_PERCENT_OF_PAR_get, Swig_var_PriceQuoteMethod_PERCENT_OF_PAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceQuoteMethod_STANDARD_MONEY_PER_UNIT_OF_A_PHYSICAL",Swig_var_PriceQuoteMethod_STANDARD_MONEY_PER_UNIT_OF_A_PHYSICAL_get, Swig_var_PriceQuoteMethod_STANDARD_MONEY_PER_UNIT_OF_A_PHYSICAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceQuoteMethod_INDEX",Swig_var_PriceQuoteMethod_INDEX_get, Swig_var_PriceQuoteMethod_INDEX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceQuoteMethod_INTEREST_RATE_INDEX",Swig_var_PriceQuoteMethod_INTEREST_RATE_INDEX_get, Swig_var_PriceQuoteMethod_INTEREST_RATE_INDEX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER",Swig_var_SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER_get, Swig_var_SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_COMPID_PROBLEM",Swig_var_SessionRejectReason_COMPID_PROBLEM_get, Swig_var_SessionRejectReason_COMPID_PROBLEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_SIGNATURE_PROBLEM",Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_get, Swig_var_SessionRejectReason_SIGNATURE_PROBLEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE",Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_get, Swig_var_SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_XML_VALIDATION_ERROR",Swig_var_SessionRejectReason_XML_VALIDATION_ERROR_get, Swig_var_SessionRejectReason_XML_VALIDATION_ERROR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_UNDEFINED_TAG",Swig_var_SessionRejectReason_UNDEFINED_TAG_get, Swig_var_SessionRejectReason_UNDEFINED_TAG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE",Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_get, Swig_var_SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER",Swig_var_SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER_get, Swig_var_SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_REQUIRED_TAG_MISSING",Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_get, Swig_var_SessionRejectReason_REQUIRED_TAG_MISSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_OTHER",Swig_var_SessionRejectReason_OTHER_get, Swig_var_SessionRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP",Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_get, Swig_var_SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE",Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_get, Swig_var_SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER",Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_get, Swig_var_SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_DECRYPTION_PROBLEM",Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_get, Swig_var_SessionRejectReason_DECRYPTION_PROBLEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INVALID_TAG_NUMBER",Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_get, Swig_var_SessionRejectReason_INVALID_TAG_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_VALUE_IS_INCORRECT",Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_get, Swig_var_SessionRejectReason_VALUE_IS_INCORRECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE",Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_get, Swig_var_SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_INVALID_MSGTYPE",Swig_var_SessionRejectReason_INVALID_MSGTYPE_get, Swig_var_SessionRejectReason_INVALID_MSGTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM",Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_get, Swig_var_SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryType_TRI_PARTY",Swig_var_DeliveryType_TRI_PARTY_get, Swig_var_DeliveryType_TRI_PARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryType_HOLD_IN_CUSTODY",Swig_var_DeliveryType_HOLD_IN_CUSTODY_get, Swig_var_DeliveryType_HOLD_IN_CUSTODY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryType_FREE_DELIVER",Swig_var_DeliveryType_FREE_DELIVER_get, Swig_var_DeliveryType_FREE_DELIVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeliveryType_VERSUS_PAYMENT_DELIVER",Swig_var_DeliveryType_VERSUS_PAYMENT_DELIVER_get, Swig_var_DeliveryType_VERSUS_PAYMENT_DELIVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Scope_LOCAL",Swig_var_Scope_LOCAL_get, Swig_var_Scope_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Scope_LOCAL_MARKET",Swig_var_Scope_LOCAL_MARKET_get, Swig_var_Scope_LOCAL_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Scope_GLOBAL",Swig_var_Scope_GLOBAL_get, Swig_var_Scope_GLOBAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Scope_NATIONAL",Swig_var_Scope_NATIONAL_get, Swig_var_Scope_NATIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeleteReason_CANCELLATION",Swig_var_DeleteReason_CANCELLATION_get, Swig_var_DeleteReason_CANCELLATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeleteReason_CANCELATION",Swig_var_DeleteReason_CANCELATION_get, Swig_var_DeleteReason_CANCELATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeleteReason_ERROR",Swig_var_DeleteReason_ERROR_get, Swig_var_DeleteReason_ERROR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InViewOfCommon_NO",Swig_var_InViewOfCommon_NO_get, Swig_var_InViewOfCommon_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InViewOfCommon_YES",Swig_var_InViewOfCommon_YES_get, Swig_var_InViewOfCommon_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NoSides_ONE_SIDE",Swig_var_NoSides_ONE_SIDE_get, Swig_var_NoSides_ONE_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NoSides_BOTH_SIDES",Swig_var_NoSides_BOTH_SIDES_get, Swig_var_NoSides_BOTH_SIDES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EURO_CERTIFICATE_OF_DEPOSIT",Swig_var_SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_get, Swig_var_SecurityType_EURO_CERTIFICATE_OF_DEPOSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MUNICIPAL_BOND",Swig_var_SecurityType_MUNICIPAL_BOND_get, Swig_var_SecurityType_MUNICIPAL_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGE_INTEREST_ONLY",Swig_var_SecurityType_MORTGAGE_INTEREST_ONLY_get, Swig_var_SecurityType_MORTGAGE_INTEREST_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MATURED",Swig_var_SecurityType_MATURED_get, Swig_var_SecurityType_MATURED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FUTURE",Swig_var_SecurityType_FUTURE_get, Swig_var_SecurityType_FUTURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TREASURY_BILL",Swig_var_SecurityType_TREASURY_BILL_get, Swig_var_SecurityType_TREASURY_BILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BILL_OF_EXCHANGES",Swig_var_SecurityType_BILL_OF_EXCHANGES_get, Swig_var_SecurityType_BILL_OF_EXCHANGES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TIME_DEPOSIT",Swig_var_SecurityType_TIME_DEPOSIT_get, Swig_var_SecurityType_TIME_DEPOSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGE_IOETTE",Swig_var_SecurityType_MORTGAGE_IOETTE_get, Swig_var_SecurityType_MORTGAGE_IOETTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REPURCHASE_AGREEMENT",Swig_var_SecurityType_REPURCHASE_AGREEMENT_get, Swig_var_SecurityType_REPURCHASE_AGREEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SPECIAL_OBLIGATION",Swig_var_SecurityType_SPECIAL_OBLIGATION_get, Swig_var_SecurityType_SPECIAL_OBLIGATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_COMMERCIAL_PAPER",Swig_var_SecurityType_COMMERCIAL_PAPER_get, Swig_var_SecurityType_COMMERCIAL_PAPER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CORPORATE_BOND",Swig_var_SecurityType_CORPORATE_BOND_get, Swig_var_SecurityType_CORPORATE_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CORP_MORTGAGE_BACKED_SECURITIES",Swig_var_SecurityType_CORP_MORTGAGE_BACKED_SECURITIES_get, Swig_var_SecurityType_CORP_MORTGAGE_BACKED_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC",Swig_var_SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC_get, Swig_var_SecurityType_OTHER_ANTICIPATION_NOTES_BAN_GAN_ETC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_STRUCTURED_NOTES",Swig_var_SecurityType_STRUCTURED_NOTES_get, Swig_var_SecurityType_STRUCTURED_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REPURCHASE",Swig_var_SecurityType_REPURCHASE_get, Swig_var_SecurityType_REPURCHASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CANADIAN_MORTGAGE_BONDS",Swig_var_SecurityType_CANADIAN_MORTGAGE_BONDS_get, Swig_var_SecurityType_CANADIAN_MORTGAGE_BONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE",Swig_var_SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE_get, Swig_var_SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE",Swig_var_SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE_get, Swig_var_SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TAX_REVENUE_ANTICIPATION_NOTE",Swig_var_SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_get, Swig_var_SecurityType_TAX_REVENUE_ANTICIPATION_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_TREASURY_BILL",Swig_var_SecurityType_US_TREASURY_BILL_get, Swig_var_SecurityType_US_TREASURY_BILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PLAZOS_FIJOS",Swig_var_SecurityType_PLAZOS_FIJOS_get, Swig_var_SecurityType_PLAZOS_FIJOS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CANADIAN_TREASURY_NOTES",Swig_var_SecurityType_CANADIAN_TREASURY_NOTES_get, Swig_var_SecurityType_CANADIAN_TREASURY_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_YANKEE_CORPORATE_BOND",Swig_var_SecurityType_YANKEE_CORPORATE_BOND_get, Swig_var_SecurityType_YANKEE_CORPORATE_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE",Swig_var_SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_get, Swig_var_SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BUY_SELLBACK",Swig_var_SecurityType_BUY_SELLBACK_get, Swig_var_SecurityType_BUY_SELLBACK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_NO_ISITC_SECURITY_TYPE",Swig_var_SecurityType_NO_ISITC_SECURITY_TYPE_get, Swig_var_SecurityType_NO_ISITC_SECURITY_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PROMISSORY_NOTE",Swig_var_SecurityType_PROMISSORY_NOTE_get, Swig_var_SecurityType_PROMISSORY_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PRIVATE_EXPORT_FUNDING",Swig_var_SecurityType_PRIVATE_EXPORT_FUNDING_get, Swig_var_SecurityType_PRIVATE_EXPORT_FUNDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CASH",Swig_var_SecurityType_CASH_get, Swig_var_SecurityType_CASH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_DEPOSIT_NOTES",Swig_var_SecurityType_DEPOSIT_NOTES_get, Swig_var_SecurityType_DEPOSIT_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FOREIGN_EXCHANGE_CONTRACT",Swig_var_SecurityType_FOREIGN_EXCHANGE_CONTRACT_get, Swig_var_SecurityType_FOREIGN_EXCHANGE_CONTRACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SECURITIES_PLEDGE",Swig_var_SecurityType_SECURITIES_PLEDGE_get, Swig_var_SecurityType_SECURITIES_PLEDGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_RETIRED",Swig_var_SecurityType_RETIRED_get, Swig_var_SecurityType_RETIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OVERNIGHT",Swig_var_SecurityType_OVERNIGHT_get, Swig_var_SecurityType_OVERNIGHT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REVENUE_ANTICIPATION_NOTE",Swig_var_SecurityType_REVENUE_ANTICIPATION_NOTE_get, Swig_var_SecurityType_REVENUE_ANTICIPATION_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REVERSE_REPURCHASE_AGREEMENT",Swig_var_SecurityType_REVERSE_REPURCHASE_AGREEMENT_get, Swig_var_SecurityType_REVERSE_REPURCHASE_AGREEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION",Swig_var_SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_get, Swig_var_SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_WARRANT",Swig_var_SecurityType_WARRANT_get, Swig_var_SecurityType_WARRANT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_LIQUIDITY_NOTE",Swig_var_SecurityType_LIQUIDITY_NOTE_get, Swig_var_SecurityType_LIQUIDITY_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MANDATORY_TENDER",Swig_var_SecurityType_MANDATORY_TENDER_get, Swig_var_SecurityType_MANDATORY_TENDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_COMMON_STOCK",Swig_var_SecurityType_COMMON_STOCK_get, Swig_var_SecurityType_COMMON_STOCK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EURO_CORPORATE_BOND",Swig_var_SecurityType_EURO_CORPORATE_BOND_get, Swig_var_SecurityType_EURO_CORPORATE_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CALL_LOANS",Swig_var_SecurityType_CALL_LOANS_get, Swig_var_SecurityType_CALL_LOANS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OPTIONS_ON_PHYSICAL",Swig_var_SecurityType_OPTIONS_ON_PHYSICAL_get, Swig_var_SecurityType_OPTIONS_ON_PHYSICAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REVOLVER_LOAN",Swig_var_SecurityType_REVOLVER_LOAN_get, Swig_var_SecurityType_REVOLVER_LOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OPTION",Swig_var_SecurityType_OPTION_get, Swig_var_SecurityType_OPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FEDERAL_AGENCY_COUPON",Swig_var_SecurityType_FEDERAL_AGENCY_COUPON_get, Swig_var_SecurityType_FEDERAL_AGENCY_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TAX_ALLOCATION",Swig_var_SecurityType_TAX_ALLOCATION_get, Swig_var_SecurityType_TAX_ALLOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MISCELLANEOUS_PASS_THROUGH",Swig_var_SecurityType_MISCELLANEOUS_PASS_THROUGH_get, Swig_var_SecurityType_MISCELLANEOUS_PASS_THROUGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_VARIABLE_RATE_DEMAND_NOTE",Swig_var_SecurityType_VARIABLE_RATE_DEMAND_NOTE_get, Swig_var_SecurityType_VARIABLE_RATE_DEMAND_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGE_PRINCIPAL_ONLY",Swig_var_SecurityType_MORTGAGE_PRINCIPAL_ONLY_get, Swig_var_SecurityType_MORTGAGE_PRINCIPAL_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TAXABLE_MUNICIPAL_CP",Swig_var_SecurityType_TAXABLE_MUNICIPAL_CP_get, Swig_var_SecurityType_TAXABLE_MUNICIPAL_CP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_INTEREST_RATE_SWAP",Swig_var_SecurityType_INTEREST_RATE_SWAP_get, Swig_var_SecurityType_INTEREST_RATE_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BANK_NOTES",Swig_var_SecurityType_BANK_NOTES_get, Swig_var_SecurityType_BANK_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_ASSET_BACKED_SECURITIES",Swig_var_SecurityType_ASSET_BACKED_SECURITIES_get, Swig_var_SecurityType_ASSET_BACKED_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MULTILEG_INSTRUMENT",Swig_var_SecurityType_MULTILEG_INSTRUMENT_get, Swig_var_SecurityType_MULTILEG_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE",Swig_var_SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE_get, Swig_var_SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CREDIT_DEFAULT_SWAP",Swig_var_SecurityType_CREDIT_DEFAULT_SWAP_get, Swig_var_SecurityType_CREDIT_DEFAULT_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION",Swig_var_SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_get, Swig_var_SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_USD_SUPRANATIONAL_COUPONS",Swig_var_SecurityType_USD_SUPRANATIONAL_COUPONS_get, Swig_var_SecurityType_USD_SUPRANATIONAL_COUPONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REVOLVER_TERM_LOAN",Swig_var_SecurityType_REVOLVER_TERM_LOAN_get, Swig_var_SecurityType_REVOLVER_TERM_LOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGE_PRINCIPLE_ONLY",Swig_var_SecurityType_MORTGAGE_PRINCIPLE_ONLY_get, Swig_var_SecurityType_MORTGAGE_PRINCIPLE_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REPLACED",Swig_var_SecurityType_REPLACED_get, Swig_var_SecurityType_REPLACED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_TREASURY_BILL_TBILL",Swig_var_SecurityType_US_TREASURY_BILL_TBILL_get, Swig_var_SecurityType_US_TREASURY_BILL_TBILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CERTIFICATE_OF_DEPOSIT",Swig_var_SecurityType_CERTIFICATE_OF_DEPOSIT_get, Swig_var_SecurityType_CERTIFICATE_OF_DEPOSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SPECIAL_ASSESSMENT",Swig_var_SecurityType_SPECIAL_ASSESSMENT_get, Swig_var_SecurityType_SPECIAL_ASSESSMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SHORT_TERM_LOAN_NOTE",Swig_var_SecurityType_SHORT_TERM_LOAN_NOTE_get, Swig_var_SecurityType_SHORT_TERM_LOAN_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_LETTER_OF_CREDIT",Swig_var_SecurityType_LETTER_OF_CREDIT_get, Swig_var_SecurityType_LETTER_OF_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OPTIONS_ON_COMBO",Swig_var_SecurityType_OPTIONS_ON_COMBO_get, Swig_var_SecurityType_OPTIONS_ON_COMBO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SPECIAL_TAX",Swig_var_SecurityType_SPECIAL_TAX_get, Swig_var_SecurityType_SPECIAL_TAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PREFERRED_STOCK",Swig_var_SecurityType_PREFERRED_STOCK_get, Swig_var_SecurityType_PREFERRED_STOCK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_TREASURY_NOTE_TNOTE",Swig_var_SecurityType_US_TREASURY_NOTE_TNOTE_get, Swig_var_SecurityType_US_TREASURY_NOTE_TNOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_AGENCY_POOLS",Swig_var_SecurityType_AGENCY_POOLS_get, Swig_var_SecurityType_AGENCY_POOLS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MEDIUM_TERM_NOTES",Swig_var_SecurityType_MEDIUM_TERM_NOTES_get, Swig_var_SecurityType_MEDIUM_TERM_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CANADIAN_PROVINCIAL_BONDS",Swig_var_SecurityType_CANADIAN_PROVINCIAL_BONDS_get, Swig_var_SecurityType_CANADIAN_PROVINCIAL_BONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_IOETTE_MORTGAGE",Swig_var_SecurityType_IOETTE_MORTGAGE_get, Swig_var_SecurityType_IOETTE_MORTGAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION",Swig_var_SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_get, Swig_var_SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SECURITIES_LOAN",Swig_var_SecurityType_SECURITIES_LOAN_get, Swig_var_SecurityType_SECURITIES_LOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES",Swig_var_SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES_get, Swig_var_SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CERTIFICATE_OF_PARTICIPATION",Swig_var_SecurityType_CERTIFICATE_OF_PARTICIPATION_get, Swig_var_SecurityType_CERTIFICATE_OF_PARTICIPATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FEDERAL_HOME_LOAN",Swig_var_SecurityType_FEDERAL_HOME_LOAN_get, Swig_var_SecurityType_FEDERAL_HOME_LOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_CORPORATE_FLOATING_RATE_NOTES",Swig_var_SecurityType_US_CORPORATE_FLOATING_RATE_NOTES_get, Swig_var_SecurityType_US_CORPORATE_FLOATING_RATE_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT",Swig_var_SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_get, Swig_var_SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MULTI_LEG_INSTRUMENT",Swig_var_SecurityType_MULTI_LEG_INSTRUMENT_get, Swig_var_SecurityType_MULTI_LEG_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_WITHDRAWN",Swig_var_SecurityType_WITHDRAWN_get, Swig_var_SecurityType_WITHDRAWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MISCELLANEOUS_PASS_THRU",Swig_var_SecurityType_MISCELLANEOUS_PASS_THRU_get, Swig_var_SecurityType_MISCELLANEOUS_PASS_THRU_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CANADIAN_MONEY_MARKETS",Swig_var_SecurityType_CANADIAN_MONEY_MARKETS_get, Swig_var_SecurityType_CANADIAN_MONEY_MARKETS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FORWARD",Swig_var_SecurityType_FORWARD_get, Swig_var_SecurityType_FORWARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EURO_SUPRANATIONAL_COUPONS",Swig_var_SecurityType_EURO_SUPRANATIONAL_COUPONS_get, Swig_var_SecurityType_EURO_SUPRANATIONAL_COUPONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE",Swig_var_SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE_get, Swig_var_SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EURO_SOVEREIGNS",Swig_var_SecurityType_EURO_SOVEREIGNS_get, Swig_var_SecurityType_EURO_SOVEREIGNS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CERTIFICATE_OF_OBLIGATION",Swig_var_SecurityType_CERTIFICATE_OF_OBLIGATION_get, Swig_var_SecurityType_CERTIFICATE_OF_OBLIGATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BANK_DEPOSITORY_NOTE",Swig_var_SecurityType_BANK_DEPOSITORY_NOTE_get, Swig_var_SecurityType_BANK_DEPOSITORY_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_TREASURY_BILL_USTB",Swig_var_SecurityType_US_TREASURY_BILL_USTB_get, Swig_var_SecurityType_US_TREASURY_BILL_USTB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FX_SWAP",Swig_var_SecurityType_FX_SWAP_get, Swig_var_SecurityType_FX_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_WILDCARD_ENTRY",Swig_var_SecurityType_WILDCARD_ENTRY_get, Swig_var_SecurityType_WILDCARD_ENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SWING_LINE_FACILITY",Swig_var_SecurityType_SWING_LINE_FACILITY_get, Swig_var_SecurityType_SWING_LINE_FACILITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FEDERAL_HOUSING_AUTHORITY",Swig_var_SecurityType_FEDERAL_HOUSING_AUTHORITY_get, Swig_var_SecurityType_FEDERAL_HOUSING_AUTHORITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CORPORATE_PRIVATE_PLACEMENT",Swig_var_SecurityType_CORPORATE_PRIVATE_PLACEMENT_get, Swig_var_SecurityType_CORPORATE_PRIVATE_PLACEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_GENERAL_OBLIGATION_BONDS",Swig_var_SecurityType_GENERAL_OBLIGATION_BONDS_get, Swig_var_SecurityType_GENERAL_OBLIGATION_BONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST",Swig_var_SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST_get, Swig_var_SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_INDEXED_LINKED",Swig_var_SecurityType_INDEXED_LINKED_get, Swig_var_SecurityType_INDEXED_LINKED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TO_BE_ANNOUNCED",Swig_var_SecurityType_TO_BE_ANNOUNCED_get, Swig_var_SecurityType_TO_BE_ANNOUNCED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES",Swig_var_SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_get, Swig_var_SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_NON_DELIVERABLE_FORWARD",Swig_var_SecurityType_NON_DELIVERABLE_FORWARD_get, Swig_var_SecurityType_NON_DELIVERABLE_FORWARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OPTIONS_ON_FUTURES",Swig_var_SecurityType_OPTIONS_ON_FUTURES_get, Swig_var_SecurityType_OPTIONS_ON_FUTURES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TAX_ANTICIPATION_NOTE",Swig_var_SecurityType_TAX_ANTICIPATION_NOTE_get, Swig_var_SecurityType_TAX_ANTICIPATION_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TERM_LOAN",Swig_var_SecurityType_TERM_LOAN_get, Swig_var_SecurityType_TERM_LOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_AMENDED_RESTATED",Swig_var_SecurityType_AMENDED_RESTATED_get, Swig_var_SecurityType_AMENDED_RESTATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FX_FORWARD",Swig_var_SecurityType_FX_FORWARD_get, Swig_var_SecurityType_FX_FORWARD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CANADIAN_TREASURY_BILLS",Swig_var_SecurityType_CANADIAN_TREASURY_BILLS_get, Swig_var_SecurityType_CANADIAN_TREASURY_BILLS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_DUAL_CURRENCY",Swig_var_SecurityType_DUAL_CURRENCY_get, Swig_var_SecurityType_DUAL_CURRENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGE_PRIVATE_PLACEMENT",Swig_var_SecurityType_MORTGAGE_PRIVATE_PLACEMENT_get, Swig_var_SecurityType_MORTGAGE_PRIVATE_PLACEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EURO_COMMERCIAL_PAPER",Swig_var_SecurityType_EURO_COMMERCIAL_PAPER_get, Swig_var_SecurityType_EURO_COMMERCIAL_PAPER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION",Swig_var_SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_get, Swig_var_SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_TREASURY_BOND",Swig_var_SecurityType_US_TREASURY_BOND_get, Swig_var_SecurityType_US_TREASURY_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_SECURED_LIQUIDITY_NOTE",Swig_var_SecurityType_SECURED_LIQUIDITY_NOTE_get, Swig_var_SecurityType_SECURED_LIQUIDITY_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MORTGAGE_BACKED_SECURITIES",Swig_var_SecurityType_MORTGAGE_BACKED_SECURITIES_get, Swig_var_SecurityType_MORTGAGE_BACKED_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_TREASURY_NOTE_UST",Swig_var_SecurityType_US_TREASURY_NOTE_UST_get, Swig_var_SecurityType_US_TREASURY_NOTE_UST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_DEBTOR_IN_POSSESSION",Swig_var_SecurityType_DEBTOR_IN_POSSESSION_get, Swig_var_SecurityType_DEBTOR_IN_POSSESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TERM_LIQUIDITY_NOTE",Swig_var_SecurityType_TERM_LIQUIDITY_NOTE_get, Swig_var_SecurityType_TERM_LIQUIDITY_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_US_TREASURY_NOTE_BOND",Swig_var_SecurityType_US_TREASURY_NOTE_BOND_get, Swig_var_SecurityType_US_TREASURY_NOTE_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_REVENUE_BONDS",Swig_var_SecurityType_REVENUE_BONDS_get, Swig_var_SecurityType_REVENUE_BONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BRIDGE_LOAN",Swig_var_SecurityType_BRIDGE_LOAN_get, Swig_var_SecurityType_BRIDGE_LOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CATS_TIGERS_LIONS",Swig_var_SecurityType_CATS_TIGERS_LIONS_get, Swig_var_SecurityType_CATS_TIGERS_LIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BRADY_BOND",Swig_var_SecurityType_BRADY_BOND_get, Swig_var_SecurityType_BRADY_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_NO_SECURITY_TYPE",Swig_var_SecurityType_NO_SECURITY_TYPE_get, Swig_var_SecurityType_NO_SECURITY_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER",Swig_var_SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_get, Swig_var_SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION",Swig_var_SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION_get, Swig_var_SecurityType_COLLATERALIZE_MORTGAGE_OBLIGATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_DEFAULTED",Swig_var_SecurityType_DEFAULTED_get, Swig_var_SecurityType_DEFAULTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_OTHER_ANTICIPATION_NOTES",Swig_var_SecurityType_OTHER_ANTICIPATION_NOTES_get, Swig_var_SecurityType_OTHER_ANTICIPATION_NOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_MUTUAL_FUND",Swig_var_SecurityType_MUTUAL_FUND_get, Swig_var_SecurityType_MUTUAL_FUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_EXTENDED_COMM_NOTE",Swig_var_SecurityType_EXTENDED_COMM_NOTE_get, Swig_var_SecurityType_EXTENDED_COMM_NOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_CONVERTIBLE_BOND",Swig_var_SecurityType_CONVERTIBLE_BOND_get, Swig_var_SecurityType_CONVERTIBLE_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_PFANDBRIEFE",Swig_var_SecurityType_PFANDBRIEFE_get, Swig_var_SecurityType_PFANDBRIEFE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_FX_SPOT",Swig_var_SecurityType_FX_SPOT_get, Swig_var_SecurityType_FX_SPOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityType_BANKERS_ACCEPTANCE",Swig_var_SecurityType_BANKERS_ACCEPTANCE_get, Swig_var_SecurityType_BANKERS_ACCEPTANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoundingDirection_ROUND_DOWN",Swig_var_RoundingDirection_ROUND_DOWN_get, Swig_var_RoundingDirection_ROUND_DOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoundingDirection_ROUND_TO_NEAREST",Swig_var_RoundingDirection_ROUND_TO_NEAREST_get, Swig_var_RoundingDirection_ROUND_TO_NEAREST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RoundingDirection_ROUND_UP",Swig_var_RoundingDirection_ROUND_UP_get, Swig_var_RoundingDirection_ROUND_UP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeUnit_MINUTE",Swig_var_TimeUnit_MINUTE_get, Swig_var_TimeUnit_MINUTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeUnit_WEEK",Swig_var_TimeUnit_WEEK_get, Swig_var_TimeUnit_WEEK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeUnit_SECOND",Swig_var_TimeUnit_SECOND_get, Swig_var_TimeUnit_SECOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeUnit_MONTH",Swig_var_TimeUnit_MONTH_get, Swig_var_TimeUnit_MONTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeUnit_HOUR",Swig_var_TimeUnit_HOUR_get, Swig_var_TimeUnit_HOUR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeUnit_DAY",Swig_var_TimeUnit_DAY_get, Swig_var_TimeUnit_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TimeUnit_YEAR",Swig_var_TimeUnit_YEAR_get, Swig_var_TimeUnit_YEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LegSwapType_MODIFIED_DURATION",Swig_var_LegSwapType_MODIFIED_DURATION_get, Swig_var_LegSwapType_MODIFIED_DURATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LegSwapType_RISK",Swig_var_LegSwapType_RISK_get, Swig_var_LegSwapType_RISK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LegSwapType_PAR_FOR_PAR",Swig_var_LegSwapType_PAR_FOR_PAR_get, Swig_var_LegSwapType_PAR_FOR_PAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LegSwapType_PROCEEDS",Swig_var_LegSwapType_PROCEEDS_get, Swig_var_LegSwapType_PROCEEDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOITransType_REPLACE",Swig_var_IOITransType_REPLACE_get, Swig_var_IOITransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOITransType_NEW",Swig_var_IOITransType_NEW_get, Swig_var_IOITransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOITransType_CANCEL",Swig_var_IOITransType_CANCEL_get, Swig_var_IOITransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_VALID_REQUEST",Swig_var_PosReqResult_VALID_REQUEST_get, Swig_var_PosReqResult_VALID_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS",Swig_var_PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS_get, Swig_var_PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA",Swig_var_PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA_get, Swig_var_PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST",Swig_var_PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST_get, Swig_var_PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_OTHER",Swig_var_PosReqResult_OTHER_get, Swig_var_PosReqResult_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED",Swig_var_PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED_get, Swig_var_PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_DEFAULT",Swig_var_SettlInstMode_DEFAULT_get, Swig_var_SettlInstMode_DEFAULT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_REQUEST_REJECT",Swig_var_SettlInstMode_REQUEST_REJECT_get, Swig_var_SettlInstMode_REQUEST_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING",Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING_get, Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING",Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING_get, Swig_var_SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT",Swig_var_SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT_get, Swig_var_SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED",Swig_var_SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED_get, Swig_var_SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PreviouslyReported_NO",Swig_var_PreviouslyReported_NO_get, Swig_var_PreviouslyReported_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PreviouslyReported_YES",Swig_var_PreviouslyReported_YES_get, Swig_var_PreviouslyReported_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_PEGGED",Swig_var_CustOrderHandlingInst_PEGGED_get, Swig_var_CustOrderHandlingInst_PEGGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_MARKET_ON_OPEN",Swig_var_CustOrderHandlingInst_MARKET_ON_OPEN_get, Swig_var_CustOrderHandlingInst_MARKET_ON_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_SCALE",Swig_var_CustOrderHandlingInst_SCALE_get, Swig_var_CustOrderHandlingInst_SCALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_FILL_OR_KILL",Swig_var_CustOrderHandlingInst_FILL_OR_KILL_get, Swig_var_CustOrderHandlingInst_FILL_OR_KILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_ALL_OR_NONE",Swig_var_CustOrderHandlingInst_ALL_OR_NONE_get, Swig_var_CustOrderHandlingInst_ALL_OR_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_NOT_HELD",Swig_var_CustOrderHandlingInst_NOT_HELD_get, Swig_var_CustOrderHandlingInst_NOT_HELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_DIRECTED_ORDER",Swig_var_CustOrderHandlingInst_DIRECTED_ORDER_get, Swig_var_CustOrderHandlingInst_DIRECTED_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_STOP_STOCK_TRANSACTION",Swig_var_CustOrderHandlingInst_STOP_STOCK_TRANSACTION_get, Swig_var_CustOrderHandlingInst_STOP_STOCK_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_OVER_THE_DAY",Swig_var_CustOrderHandlingInst_OVER_THE_DAY_get, Swig_var_CustOrderHandlingInst_OVER_THE_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_ADD_ON_ORDER",Swig_var_CustOrderHandlingInst_ADD_ON_ORDER_get, Swig_var_CustOrderHandlingInst_ADD_ON_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_MARKET_AT_CLOSE",Swig_var_CustOrderHandlingInst_MARKET_AT_CLOSE_get, Swig_var_CustOrderHandlingInst_MARKET_AT_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_LIMIT_ON_OPEN",Swig_var_CustOrderHandlingInst_LIMIT_ON_OPEN_get, Swig_var_CustOrderHandlingInst_LIMIT_ON_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_CASH_NOT_HELD",Swig_var_CustOrderHandlingInst_CASH_NOT_HELD_get, Swig_var_CustOrderHandlingInst_CASH_NOT_HELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_MARKET_ON_CLOSE",Swig_var_CustOrderHandlingInst_MARKET_ON_CLOSE_get, Swig_var_CustOrderHandlingInst_MARKET_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_TIME_ORDER",Swig_var_CustOrderHandlingInst_TIME_ORDER_get, Swig_var_CustOrderHandlingInst_TIME_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_LIMIT_ON_CLOSE",Swig_var_CustOrderHandlingInst_LIMIT_ON_CLOSE_get, Swig_var_CustOrderHandlingInst_LIMIT_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_IMMEDIATE_OR_CANCEL",Swig_var_CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_get, Swig_var_CustOrderHandlingInst_IMMEDIATE_OR_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_TRAILING_STOP",Swig_var_CustOrderHandlingInst_TRAILING_STOP_get, Swig_var_CustOrderHandlingInst_TRAILING_STOP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_WORK",Swig_var_CustOrderHandlingInst_WORK_get, Swig_var_CustOrderHandlingInst_WORK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_RESERVE_SIZE_ORDER",Swig_var_CustOrderHandlingInst_RESERVE_SIZE_ORDER_get, Swig_var_CustOrderHandlingInst_RESERVE_SIZE_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_MINIMUM_QUANTITY",Swig_var_CustOrderHandlingInst_MINIMUM_QUANTITY_get, Swig_var_CustOrderHandlingInst_MINIMUM_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_MARKET_AT_OPEN",Swig_var_CustOrderHandlingInst_MARKET_AT_OPEN_get, Swig_var_CustOrderHandlingInst_MARKET_AT_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_IMBALANCE_ONLY",Swig_var_CustOrderHandlingInst_IMBALANCE_ONLY_get, Swig_var_CustOrderHandlingInst_IMBALANCE_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION",Swig_var_CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get, Swig_var_CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityStatus_INACTIVE",Swig_var_SecurityStatus_INACTIVE_get, Swig_var_SecurityStatus_INACTIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityStatus_ACTIVE",Swig_var_SecurityStatus_ACTIVE_get, Swig_var_SecurityStatus_ACTIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_SOFT_DOLLAR",Swig_var_ProcessCode_SOFT_DOLLAR_get, Swig_var_ProcessCode_SOFT_DOLLAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_PLAN_SPONSOR",Swig_var_ProcessCode_PLAN_SPONSOR_get, Swig_var_ProcessCode_PLAN_SPONSOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_STEP_IN",Swig_var_ProcessCode_STEP_IN_get, Swig_var_ProcessCode_STEP_IN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_REGULAR",Swig_var_ProcessCode_REGULAR_get, Swig_var_ProcessCode_REGULAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_SOFT_DOLLAR_STEP_OUT",Swig_var_ProcessCode_SOFT_DOLLAR_STEP_OUT_get, Swig_var_ProcessCode_SOFT_DOLLAR_STEP_OUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_STEP_OUT",Swig_var_ProcessCode_STEP_OUT_get, Swig_var_ProcessCode_STEP_OUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ProcessCode_SOFT_DOLLAR_STEP_IN",Swig_var_ProcessCode_SOFT_DOLLAR_STEP_IN_get, Swig_var_ProcessCode_SOFT_DOLLAR_STEP_IN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRY_TO_STOP",Swig_var_ExecInst_TRY_TO_STOP_get, Swig_var_ExecInst_TRY_TO_STOP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PEG_TO_LIMIT_PRICE",Swig_var_ExecInst_PEG_TO_LIMIT_PRICE_get, Swig_var_ExecInst_PEG_TO_LIMIT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_EXECUTE_AS_DURATION_NEUTRAL",Swig_var_ExecInst_EXECUTE_AS_DURATION_NEUTRAL_get, Swig_var_ExecInst_EXECUTE_AS_DURATION_NEUTRAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_REINSTATE_ON_TRADING_HALT",Swig_var_ExecInst_REINSTATE_ON_TRADING_HALT_get, Swig_var_ExecInst_REINSTATE_ON_TRADING_HALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_NO_CROSS",Swig_var_ExecInst_NO_CROSS_get, Swig_var_ExecInst_NO_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PEGVWAP",Swig_var_ExecInst_PEGVWAP_get, Swig_var_ExecInst_PEGVWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STRICT_SCALE",Swig_var_ExecInst_STRICT_SCALE_get, Swig_var_ExecInst_STRICT_SCALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_AON",Swig_var_ExecInst_AON_get, Swig_var_ExecInst_AON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_MARKPEG",Swig_var_ExecInst_MARKPEG_get, Swig_var_ExecInst_MARKPEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_MIDPRCPEG",Swig_var_ExecInst_MIDPRCPEG_get, Swig_var_ExecInst_MIDPRCPEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_OKCROSS",Swig_var_ExecInst_OKCROSS_get, Swig_var_ExecInst_OKCROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRAILING_STOP_PEG",Swig_var_ExecInst_TRAILING_STOP_PEG_get, Swig_var_ExecInst_TRAILING_STOP_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_EXECUTE_AS_FX_NEUTRAL",Swig_var_ExecInst_EXECUTE_AS_FX_NEUTRAL_get, Swig_var_ExecInst_EXECUTE_AS_FX_NEUTRAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CUSTDISPINST",Swig_var_ExecInst_CUSTDISPINST_get, Swig_var_ExecInst_CUSTDISPINST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_OK_TO_CROSS",Swig_var_ExecInst_OK_TO_CROSS_get, Swig_var_ExecInst_OK_TO_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_SUSPEND_ON_SYSTEM_FAILURE",Swig_var_ExecInst_SUSPEND_ON_SYSTEM_FAILURE_get, Swig_var_ExecInst_SUSPEND_ON_SYSTEM_FAILURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_GO_ALONG",Swig_var_ExecInst_GO_ALONG_get, Swig_var_ExecInst_GO_ALONG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_INSTITONLY",Swig_var_ExecInst_INSTITONLY_get, Swig_var_ExecInst_INSTITONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_DO_NOT_INCREASE",Swig_var_ExecInst_DO_NOT_INCREASE_get, Swig_var_ExecInst_DO_NOT_INCREASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_SUSPEND",Swig_var_ExecInst_SUSPEND_get, Swig_var_ExecInst_SUSPEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRYTOSTOP",Swig_var_ExecInst_TRYTOSTOP_get, Swig_var_ExecInst_TRYTOSTOP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER",Swig_var_ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_get, Swig_var_ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_REINSTATE_ON_SYSTEM_FAILURE",Swig_var_ExecInst_REINSTATE_ON_SYSTEM_FAILURE_get, Swig_var_ExecInst_REINSTATE_ON_SYSTEM_FAILURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_SUSPEND_ON_TRADING_HALT",Swig_var_ExecInst_SUSPEND_ON_TRADING_HALT_get, Swig_var_ExecInst_SUSPEND_ON_TRADING_HALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_INTERMARKET_SWEEP",Swig_var_ExecInst_INTERMARKET_SWEEP_get, Swig_var_ExecInst_INTERMARKET_SWEEP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_BEST_EXECUTION",Swig_var_ExecInst_BEST_EXECUTION_get, Swig_var_ExecInst_BEST_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PARTICIPATE_DONT_INITIATE",Swig_var_ExecInst_PARTICIPATE_DONT_INITIATE_get, Swig_var_ExecInst_PARTICIPATE_DONT_INITIATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_LASTPEG",Swig_var_ExecInst_LASTPEG_get, Swig_var_ExecInst_LASTPEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PEG_TO_VWAP",Swig_var_ExecInst_PEG_TO_VWAP_get, Swig_var_ExecInst_PEG_TO_VWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PRIMARY_PEG",Swig_var_ExecInst_PRIMARY_PEG_get, Swig_var_ExecInst_PRIMARY_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_NONNEGO",Swig_var_ExecInst_NONNEGO_get, Swig_var_ExecInst_NONNEGO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_IGNORE_PRICE_VALIDITY_CHECKS",Swig_var_ExecInst_IGNORE_PRICE_VALIDITY_CHECKS_get, Swig_var_ExecInst_IGNORE_PRICE_VALIDITY_CHECKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STAY_ON_BID_SIDE",Swig_var_ExecInst_STAY_ON_BID_SIDE_get, Swig_var_ExecInst_STAY_ON_BID_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_NOTHELD",Swig_var_ExecInst_NOTHELD_get, Swig_var_ExecInst_NOTHELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STRICTSCALE",Swig_var_ExecInst_STRICTSCALE_get, Swig_var_ExecInst_STRICTSCALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_REINSTATE_ON_CONNECTION_LOSS",Swig_var_ExecInst_REINSTATE_ON_CONNECTION_LOSS_get, Swig_var_ExecInst_REINSTATE_ON_CONNECTION_LOSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_DNI",Swig_var_ExecInst_DNI_get, Swig_var_ExecInst_DNI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRYTOSCALE",Swig_var_ExecInst_TRYTOSCALE_get, Swig_var_ExecInst_TRYTOSCALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PERCENT_OF_VOLUME",Swig_var_ExecInst_PERCENT_OF_VOLUME_get, Swig_var_ExecInst_PERCENT_OF_VOLUME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_GOALONG",Swig_var_ExecInst_GOALONG_get, Swig_var_ExecInst_GOALONG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_WORK",Swig_var_ExecInst_WORK_get, Swig_var_ExecInst_WORK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_HELD",Swig_var_ExecInst_HELD_get, Swig_var_ExecInst_HELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_NOCROSS",Swig_var_ExecInst_NOCROSS_get, Swig_var_ExecInst_NOCROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_RELEASE_FROM_SUSPENSION",Swig_var_ExecInst_RELEASE_FROM_SUSPENSION_get, Swig_var_ExecInst_RELEASE_FROM_SUSPENSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STRICT_LIMIT",Swig_var_ExecInst_STRICT_LIMIT_get, Swig_var_ExecInst_STRICT_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_OPENPEG",Swig_var_ExecInst_OPENPEG_get, Swig_var_ExecInst_OPENPEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STAY_ON_BIDSIDE",Swig_var_ExecInst_STAY_ON_BIDSIDE_get, Swig_var_ExecInst_STAY_ON_BIDSIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STAY_ON_OFFERSIDE",Swig_var_ExecInst_STAY_ON_OFFERSIDE_get, Swig_var_ExecInst_STAY_ON_OFFERSIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_OVER_THE_DAY",Swig_var_ExecInst_OVER_THE_DAY_get, Swig_var_ExecInst_OVER_THE_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_RESTATEONTRADINGHALT",Swig_var_ExecInst_RESTATEONTRADINGHALT_get, Swig_var_ExecInst_RESTATEONTRADINGHALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_INSTITUTIONS_ONLY",Swig_var_ExecInst_INSTITUTIONS_ONLY_get, Swig_var_ExecInst_INSTITUTIONS_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_NOT_HELD",Swig_var_ExecInst_NOT_HELD_get, Swig_var_ExecInst_NOT_HELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CANCELONTRADINGHALT",Swig_var_ExecInst_CANCELONTRADINGHALT_get, Swig_var_ExecInst_CANCELONTRADINGHALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CANCELONSYSFAIL",Swig_var_ExecInst_CANCELONSYSFAIL_get, Swig_var_ExecInst_CANCELONSYSFAIL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_MARKET_PEG",Swig_var_ExecInst_MARKET_PEG_get, Swig_var_ExecInst_MARKET_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRADEALONG",Swig_var_ExecInst_TRADEALONG_get, Swig_var_ExecInst_TRADEALONG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CALL_FIRST",Swig_var_ExecInst_CALL_FIRST_get, Swig_var_ExecInst_CALL_FIRST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CANCEL_ON_SYSTEM_FAILURE",Swig_var_ExecInst_CANCEL_ON_SYSTEM_FAILURE_get, Swig_var_ExecInst_CANCEL_ON_SYSTEM_FAILURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED",Swig_var_ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED_get, Swig_var_ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE",Swig_var_ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE_get, Swig_var_ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_NON_NEGOTIABLE",Swig_var_ExecInst_NON_NEGOTIABLE_get, Swig_var_ExecInst_NON_NEGOTIABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRY_TO_SCALE",Swig_var_ExecInst_TRY_TO_SCALE_get, Swig_var_ExecInst_TRY_TO_SCALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_EXTERNAL_ROUTING_ALLOWED",Swig_var_ExecInst_EXTERNAL_ROUTING_ALLOWED_get, Swig_var_ExecInst_EXTERNAL_ROUTING_ALLOWED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STAY_ON_OFFER_SIDE",Swig_var_ExecInst_STAY_ON_OFFER_SIDE_get, Swig_var_ExecInst_STAY_ON_OFFER_SIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CUSTOMER_DISPLAY_INSTRUCTION",Swig_var_ExecInst_CUSTOMER_DISPLAY_INSTRUCTION_get, Swig_var_ExecInst_CUSTOMER_DISPLAY_INSTRUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_WORK_TO_TARGET_STRATEGY",Swig_var_ExecInst_WORK_TO_TARGET_STRATEGY_get, Swig_var_ExecInst_WORK_TO_TARGET_STRATEGY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_OVERDAY",Swig_var_ExecInst_OVERDAY_get, Swig_var_ExecInst_OVERDAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_LAST_PEG",Swig_var_ExecInst_LAST_PEG_get, Swig_var_ExecInst_LAST_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CALLFIRST",Swig_var_ExecInst_CALLFIRST_get, Swig_var_ExecInst_CALLFIRST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_REINSTATE_ON_SYSTEM_FAILUE",Swig_var_ExecInst_REINSTATE_ON_SYSTEM_FAILUE_get, Swig_var_ExecInst_REINSTATE_ON_SYSTEM_FAILUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_DO_NOT_REDUCE",Swig_var_ExecInst_DO_NOT_REDUCE_get, Swig_var_ExecInst_DO_NOT_REDUCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_MID_PRICE_PEG",Swig_var_ExecInst_MID_PRICE_PEG_get, Swig_var_ExecInst_MID_PRICE_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_ALL_OR_NONE",Swig_var_ExecInst_ALL_OR_NONE_get, Swig_var_ExecInst_ALL_OR_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_OPENING_PEG",Swig_var_ExecInst_OPENING_PEG_get, Swig_var_ExecInst_OPENING_PEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PERCVOL",Swig_var_ExecInst_PERCVOL_get, Swig_var_ExecInst_PERCVOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_SUSPEND_ON_CONNECTION_LOSS",Swig_var_ExecInst_SUSPEND_ON_CONNECTION_LOSS_get, Swig_var_ExecInst_SUSPEND_ON_CONNECTION_LOSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CANCEL_ON_CONNECTION_LOSS",Swig_var_ExecInst_CANCEL_ON_CONNECTION_LOSS_get, Swig_var_ExecInst_CANCEL_ON_CONNECTION_LOSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED",Swig_var_ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED_get, Swig_var_ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CANCEL_IF_NOT_BEST",Swig_var_ExecInst_CANCEL_IF_NOT_BEST_get, Swig_var_ExecInst_CANCEL_IF_NOT_BEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PARTNOTINIT",Swig_var_ExecInst_PARTNOTINIT_get, Swig_var_ExecInst_PARTNOTINIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_NETTING",Swig_var_ExecInst_NETTING_get, Swig_var_ExecInst_NETTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_IMBALANCE_ONLY",Swig_var_ExecInst_IMBALANCE_ONLY_get, Swig_var_ExecInst_IMBALANCE_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_DNR",Swig_var_ExecInst_DNR_get, Swig_var_ExecInst_DNR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STAYOFFER",Swig_var_ExecInst_STAYOFFER_get, Swig_var_ExecInst_STAYOFFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_STAYBID",Swig_var_ExecInst_STAYBID_get, Swig_var_ExecInst_STAYBID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_TRADE_ALONG",Swig_var_ExecInst_TRADE_ALONG_get, Swig_var_ExecInst_TRADE_ALONG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_CANCEL_ON_TRADING_HALT",Swig_var_ExecInst_CANCEL_ON_TRADING_HALT_get, Swig_var_ExecInst_CANCEL_ON_TRADING_HALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_RESTATEONSYSFAIL",Swig_var_ExecInst_RESTATEONSYSFAIL_get, Swig_var_ExecInst_RESTATEONSYSFAIL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecInst_PRIMPEG",Swig_var_ExecInst_PRIMPEG_get, Swig_var_ExecInst_PRIMPEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_REPLACE",Swig_var_ExecType_REPLACE_get, Swig_var_ExecType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_NEW",Swig_var_ExecType_NEW_get, Swig_var_ExecType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_CALCULATED",Swig_var_ExecType_CALCULATED_get, Swig_var_ExecType_CALCULATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_PENDING_CANCEL",Swig_var_ExecType_PENDING_CANCEL_get, Swig_var_ExecType_PENDING_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_TRADE_IN_A_CLEARING_HOLD",Swig_var_ExecType_TRADE_IN_A_CLEARING_HOLD_get, Swig_var_ExecType_TRADE_IN_A_CLEARING_HOLD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING",Swig_var_ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING_get, Swig_var_ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_ORDER_STATUS",Swig_var_ExecType_ORDER_STATUS_get, Swig_var_ExecType_ORDER_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_PENDING_CANCEL_REPLACE",Swig_var_ExecType_PENDING_CANCEL_REPLACE_get, Swig_var_ExecType_PENDING_CANCEL_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_PARTIAL_FILL",Swig_var_ExecType_PARTIAL_FILL_get, Swig_var_ExecType_PARTIAL_FILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_PENDING_NEW",Swig_var_ExecType_PENDING_NEW_get, Swig_var_ExecType_PENDING_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_STOPPED",Swig_var_ExecType_STOPPED_get, Swig_var_ExecType_STOPPED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_CANCELED",Swig_var_ExecType_CANCELED_get, Swig_var_ExecType_CANCELED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_PENDING_REPLACE",Swig_var_ExecType_PENDING_REPLACE_get, Swig_var_ExecType_PENDING_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_TRADE",Swig_var_ExecType_TRADE_get, Swig_var_ExecType_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_TRADE_CORRECT",Swig_var_ExecType_TRADE_CORRECT_get, Swig_var_ExecType_TRADE_CORRECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_SUSPENDED",Swig_var_ExecType_SUSPENDED_get, Swig_var_ExecType_SUSPENDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_FILL",Swig_var_ExecType_FILL_get, Swig_var_ExecType_FILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_RESTATED",Swig_var_ExecType_RESTATED_get, Swig_var_ExecType_RESTATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_REJECTED",Swig_var_ExecType_REJECTED_get, Swig_var_ExecType_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_REPLACED",Swig_var_ExecType_REPLACED_get, Swig_var_ExecType_REPLACED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_EXPIRED",Swig_var_ExecType_EXPIRED_get, Swig_var_ExecType_EXPIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_DONE_FOR_DAY",Swig_var_ExecType_DONE_FOR_DAY_get, Swig_var_ExecType_DONE_FOR_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM",Swig_var_ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM_get, Swig_var_ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_TRADE_CANCEL",Swig_var_ExecType_TRADE_CANCEL_get, Swig_var_ExecType_TRADE_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecType_CANCELLED",Swig_var_ExecType_CANCELLED_get, Swig_var_ExecType_CANCELLED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegModel_USER_DEFINED_MULTLEG_SECURITY",Swig_var_MultilegModel_USER_DEFINED_MULTLEG_SECURITY_get, Swig_var_MultilegModel_USER_DEFINED_MULTLEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegModel_PREDEFINED_MULTILEG_SECURITY",Swig_var_MultilegModel_PREDEFINED_MULTILEG_SECURITY_get, Swig_var_MultilegModel_PREDEFINED_MULTILEG_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG",Swig_var_MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG_get, Swig_var_MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_SWAP_NEXT_START_DATE",Swig_var_EventType_SWAP_NEXT_START_DATE_get, Swig_var_EventType_SWAP_NEXT_START_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_LAST_ELIGIBLE_TRADE_DATE",Swig_var_EventType_LAST_ELIGIBLE_TRADE_DATE_get, Swig_var_EventType_LAST_ELIGIBLE_TRADE_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_FIRST_DELIVERY_DATE",Swig_var_EventType_FIRST_DELIVERY_DATE_get, Swig_var_EventType_FIRST_DELIVERY_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_TENDER",Swig_var_EventType_TENDER_get, Swig_var_EventType_TENDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_INITIAL_INVENTORY_DUE_DATE",Swig_var_EventType_INITIAL_INVENTORY_DUE_DATE_get, Swig_var_EventType_INITIAL_INVENTORY_DUE_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_FIRST_INTENT_DATE",Swig_var_EventType_FIRST_INTENT_DATE_get, Swig_var_EventType_FIRST_INTENT_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_ACTIVATION",Swig_var_EventType_ACTIVATION_get, Swig_var_EventType_ACTIVATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_PUT",Swig_var_EventType_PUT_get, Swig_var_EventType_PUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_SWAP_START_DATE",Swig_var_EventType_SWAP_START_DATE_get, Swig_var_EventType_SWAP_START_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_SWAP_NEXT_ROLL_DATE",Swig_var_EventType_SWAP_NEXT_ROLL_DATE_get, Swig_var_EventType_SWAP_NEXT_ROLL_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_LAST_DELIVERY_DATE",Swig_var_EventType_LAST_DELIVERY_DATE_get, Swig_var_EventType_LAST_DELIVERY_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_POSITION_REMOVAL_DATE",Swig_var_EventType_POSITION_REMOVAL_DATE_get, Swig_var_EventType_POSITION_REMOVAL_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_SWAP_ROLL_DATE",Swig_var_EventType_SWAP_ROLL_DATE_get, Swig_var_EventType_SWAP_ROLL_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_FINAL_INVENTORY_DUE_DATE",Swig_var_EventType_FINAL_INVENTORY_DUE_DATE_get, Swig_var_EventType_FINAL_INVENTORY_DUE_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_OTHER",Swig_var_EventType_OTHER_get, Swig_var_EventType_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_INACTIVIATION",Swig_var_EventType_INACTIVIATION_get, Swig_var_EventType_INACTIVIATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_SWAP_END_DATE",Swig_var_EventType_SWAP_END_DATE_get, Swig_var_EventType_SWAP_END_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_LAST_INTENT_DATE",Swig_var_EventType_LAST_INTENT_DATE_get, Swig_var_EventType_LAST_INTENT_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_SINKING_FUND_CALL",Swig_var_EventType_SINKING_FUND_CALL_get, Swig_var_EventType_SINKING_FUND_CALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"EventType_CALL",Swig_var_EventType_CALL_get, Swig_var_EventType_CALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_ALLOCATION_REQUIRED",Swig_var_TradeAllocIndicator_ALLOCATION_REQUIRED_get, Swig_var_TradeAllocIndicator_ALLOCATION_REQUIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT",Swig_var_TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT_get, Swig_var_TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR",Swig_var_TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR_get, Swig_var_TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE",Swig_var_TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE_get, Swig_var_TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR",Swig_var_TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR_get, Swig_var_TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeAllocIndicator_ALLOCATION_NOT_REQUIRED",Swig_var_TradeAllocIndicator_ALLOCATION_NOT_REQUIRED_get, Swig_var_TradeAllocIndicator_ALLOCATION_NOT_REQUIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_NOT_LOGGED_IN",Swig_var_UserStatus_NOT_LOGGED_IN_get, Swig_var_UserStatus_NOT_LOGGED_IN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_PASSWORD_INCORRECT",Swig_var_UserStatus_PASSWORD_INCORRECT_get, Swig_var_UserStatus_PASSWORD_INCORRECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_LOGGED_IN",Swig_var_UserStatus_LOGGED_IN_get, Swig_var_UserStatus_LOGGED_IN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE",Swig_var_UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE_get, Swig_var_UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_USER_NOT_RECOGNISED",Swig_var_UserStatus_USER_NOT_RECOGNISED_get, Swig_var_UserStatus_USER_NOT_RECOGNISED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_OTHER",Swig_var_UserStatus_OTHER_get, Swig_var_UserStatus_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_PASSWORD_CHANGED",Swig_var_UserStatus_PASSWORD_CHANGED_get, Swig_var_UserStatus_PASSWORD_CHANGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UserStatus_SESSION_SHUTDOWN_WARNING",Swig_var_UserStatus_SESSION_SHUTDOWN_WARNING_get, Swig_var_UserStatus_SESSION_SHUTDOWN_WARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_WEEKS",Swig_var_OrderDelayUnit_WEEKS_get, Swig_var_OrderDelayUnit_WEEKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_TENTHS_OF_A_SECOND",Swig_var_OrderDelayUnit_TENTHS_OF_A_SECOND_get, Swig_var_OrderDelayUnit_TENTHS_OF_A_SECOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_SECONDS",Swig_var_OrderDelayUnit_SECONDS_get, Swig_var_OrderDelayUnit_SECONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_MONTHS",Swig_var_OrderDelayUnit_MONTHS_get, Swig_var_OrderDelayUnit_MONTHS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_YEARS",Swig_var_OrderDelayUnit_YEARS_get, Swig_var_OrderDelayUnit_YEARS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_NANOSECONDS",Swig_var_OrderDelayUnit_NANOSECONDS_get, Swig_var_OrderDelayUnit_NANOSECONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_HUNDREDTHS_OF_A_SECOND",Swig_var_OrderDelayUnit_HUNDREDTHS_OF_A_SECOND_get, Swig_var_OrderDelayUnit_HUNDREDTHS_OF_A_SECOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_HOURS",Swig_var_OrderDelayUnit_HOURS_get, Swig_var_OrderDelayUnit_HOURS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_MICROSECONDS",Swig_var_OrderDelayUnit_MICROSECONDS_get, Swig_var_OrderDelayUnit_MICROSECONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_MINUTES",Swig_var_OrderDelayUnit_MINUTES_get, Swig_var_OrderDelayUnit_MINUTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_MILLISECONDS",Swig_var_OrderDelayUnit_MILLISECONDS_get, Swig_var_OrderDelayUnit_MILLISECONDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrderDelayUnit_DAYS",Swig_var_OrderDelayUnit_DAYS_get, Swig_var_OrderDelayUnit_DAYS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradedFlatSwitch_NO",Swig_var_TradedFlatSwitch_NO_get, Swig_var_TradedFlatSwitch_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradedFlatSwitch_YES",Swig_var_TradedFlatSwitch_YES_get, Swig_var_TradedFlatSwitch_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRptStatus_ACCEPTED_WITH_ERRORS",Swig_var_TrdRptStatus_ACCEPTED_WITH_ERRORS_get, Swig_var_TrdRptStatus_ACCEPTED_WITH_ERRORS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRptStatus_REJECTED",Swig_var_TrdRptStatus_REJECTED_get, Swig_var_TrdRptStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TrdRptStatus_ACCEPTED",Swig_var_TrdRptStatus_ACCEPTED_get, Swig_var_TrdRptStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_PENDING",Swig_var_QuoteStatus_PENDING_get, Swig_var_QuoteStatus_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_PENDING_END_TRADE",Swig_var_QuoteStatus_PENDING_END_TRADE_get, Swig_var_QuoteStatus_PENDING_END_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CROSS_MARKET_WARNING",Swig_var_QuoteStatus_CROSS_MARKET_WARNING_get, Swig_var_QuoteStatus_CROSS_MARKET_WARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELED",Swig_var_QuoteStatus_CANCELED_get, Swig_var_QuoteStatus_CANCELED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_LOCKED_MARKET_WARNING",Swig_var_QuoteStatus_LOCKED_MARKET_WARNING_get, Swig_var_QuoteStatus_LOCKED_MARKET_WARNING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELED_FOR_UNDERLYING",Swig_var_QuoteStatus_CANCELED_FOR_UNDERLYING_get, Swig_var_QuoteStatus_CANCELED_FOR_UNDERLYING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT",Swig_var_QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT_get, Swig_var_QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_TOO_LATE_TO_END",Swig_var_QuoteStatus_TOO_LATE_TO_END_get, Swig_var_QuoteStatus_TOO_LATE_TO_END_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET",Swig_var_QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET_get, Swig_var_QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET",Swig_var_QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET_get, Swig_var_QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELED_FOR_SECURITY_TYPE",Swig_var_QuoteStatus_CANCELED_FOR_SECURITY_TYPE_get, Swig_var_QuoteStatus_CANCELED_FOR_SECURITY_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELED_ALL",Swig_var_QuoteStatus_CANCELED_ALL_get, Swig_var_QuoteStatus_CANCELED_ALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_PASS",Swig_var_QuoteStatus_PASS_get, Swig_var_QuoteStatus_PASS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_REJECTED",Swig_var_QuoteStatus_REJECTED_get, Swig_var_QuoteStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_QUERY",Swig_var_QuoteStatus_QUERY_get, Swig_var_QuoteStatus_QUERY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_ACCEPTED",Swig_var_QuoteStatus_ACCEPTED_get, Swig_var_QuoteStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_EXPIRED",Swig_var_QuoteStatus_EXPIRED_get, Swig_var_QuoteStatus_EXPIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCELED_FOR_SYMBOL",Swig_var_QuoteStatus_CANCELED_FOR_SYMBOL_get, Swig_var_QuoteStatus_CANCELED_FOR_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_REMOVED_FROM_MARKET",Swig_var_QuoteStatus_REMOVED_FROM_MARKET_get, Swig_var_QuoteStatus_REMOVED_FROM_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_ACTIVE",Swig_var_QuoteStatus_ACTIVE_get, Swig_var_QuoteStatus_ACTIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_CANCEL_FOR_SYMBOL",Swig_var_QuoteStatus_CANCEL_FOR_SYMBOL_get, Swig_var_QuoteStatus_CANCEL_FOR_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteStatus_QUOTE_NOT_FOUND",Swig_var_QuoteStatus_QUOTE_NOT_FOUND_get, Swig_var_QuoteStatus_QUOTE_NOT_FOUND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SolicitedFlag_NO",Swig_var_SolicitedFlag_NO_get, Swig_var_SolicitedFlag_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SolicitedFlag_YES",Swig_var_SolicitedFlag_YES_get, Swig_var_SolicitedFlag_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_DEALER_SOLD_SHORT",Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_get, Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT",Swig_var_ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT_get, Swig_var_ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT",Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT_get, Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT",Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_get, Swig_var_ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_QUALIFED_SERVICE_REPRESENTATIVE",Swig_var_ShortSaleReason_QUALIFED_SERVICE_REPRESENTATIVE_get, Swig_var_ShortSaleReason_QUALIFED_SERVICE_REPRESENTATIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT",Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT_get, Swig_var_ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE",Swig_var_ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE_get, Swig_var_ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK",Swig_var_PegRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK_get, Swig_var_PegRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegRoundDirection_MORE_AGGRESSIVE",Swig_var_PegRoundDirection_MORE_AGGRESSIVE_get, Swig_var_PegRoundDirection_MORE_AGGRESSIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegRoundDirection_MORE_PASSIVE",Swig_var_PegRoundDirection_MORE_PASSIVE_get, Swig_var_PegRoundDirection_MORE_PASSIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PegRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK",Swig_var_PegRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK_get, Swig_var_PegRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ModelType_PROPRIETARY",Swig_var_ModelType_PROPRIETARY_get, Swig_var_ModelType_PROPRIETARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ModelType_UTILITY_PROVIDED_STANDARD_MODEL",Swig_var_ModelType_UTILITY_PROVIDED_STANDARD_MODEL_get, Swig_var_ModelType_UTILITY_PROVIDED_STANDARD_MODEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT",Swig_var_FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_get, Swig_var_FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FuturesValuationMethod_PREMIUM_STYLE",Swig_var_FuturesValuationMethod_PREMIUM_STYLE_get, Swig_var_FuturesValuationMethod_PREMIUM_STYLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET",Swig_var_FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_get, Swig_var_FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlMethod_CASH_SETTLEMENT_REQUIRED",Swig_var_SettlMethod_CASH_SETTLEMENT_REQUIRED_get, Swig_var_SettlMethod_CASH_SETTLEMENT_REQUIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED",Swig_var_SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED_get, Swig_var_SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmStatus_CONFIRMED",Swig_var_ConfirmStatus_CONFIRMED_get, Swig_var_ConfirmStatus_CONFIRMED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS",Swig_var_ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS_get, Swig_var_ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmStatus_REQUEST_REJECTED",Swig_var_ConfirmStatus_REQUEST_REJECTED_get, Swig_var_ConfirmStatus_REQUEST_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmStatus_MISMATCHED_ACCOUNT",Swig_var_ConfirmStatus_MISMATCHED_ACCOUNT_get, Swig_var_ConfirmStatus_MISMATCHED_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmStatus_RECEIVED",Swig_var_ConfirmStatus_RECEIVED_get, Swig_var_ConfirmStatus_RECEIVED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LocateReqd_NO",Swig_var_LocateReqd_NO_get, Swig_var_LocateReqd_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LocateReqd_YES",Swig_var_LocateReqd_YES_get, Swig_var_LocateReqd_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Adjustment_CANCEL",Swig_var_Adjustment_CANCEL_get, Swig_var_Adjustment_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Adjustment_CORRECTION",Swig_var_Adjustment_CORRECTION_get, Swig_var_Adjustment_CORRECTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Adjustment_ERROR",Swig_var_Adjustment_ERROR_get, Swig_var_Adjustment_ERROR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnType_ASSIGNMENT",Swig_var_StreamAsgnType_ASSIGNMENT_get, Swig_var_StreamAsgnType_ASSIGNMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnType_TERMINATE_UNASSIGN",Swig_var_StreamAsgnType_TERMINATE_UNASSIGN_get, Swig_var_StreamAsgnType_TERMINATE_UNASSIGN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnType_REJECTED",Swig_var_StreamAsgnType_REJECTED_get, Swig_var_StreamAsgnType_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastRptRequested_NO",Swig_var_LastRptRequested_NO_get, Swig_var_LastRptRequested_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastRptRequested_YES",Swig_var_LastRptRequested_YES_get, Swig_var_LastRptRequested_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlSessID_END_OF_DAY",Swig_var_SettlSessID_END_OF_DAY_get, Swig_var_SettlSessID_END_OF_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlSessID_ELECTRONIC_TRADING_HOURS",Swig_var_SettlSessID_ELECTRONIC_TRADING_HOURS_get, Swig_var_SettlSessID_ELECTRONIC_TRADING_HOURS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlSessID_REGULAR_TRADING_HOURS",Swig_var_SettlSessID_REGULAR_TRADING_HOURS_get, Swig_var_SettlSessID_REGULAR_TRADING_HOURS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlSessID_INTRADAY",Swig_var_SettlSessID_INTRADAY_get, Swig_var_SettlSessID_INTRADAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_LOCKED_IN_TRADE_BREAK",Swig_var_TradeReportType_LOCKED_IN_TRADE_BREAK_get, Swig_var_TradeReportType_LOCKED_IN_TRADE_BREAK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_NO_WAS",Swig_var_TradeReportType_NO_WAS_get, Swig_var_TradeReportType_NO_WAS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ADDENDUM",Swig_var_TradeReportType_ADDENDUM_get, Swig_var_TradeReportType_ADDENDUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_7",Swig_var_TradeReportType_7_get, Swig_var_TradeReportType_7_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_PENDED",Swig_var_TradeReportType_PENDED_get, Swig_var_TradeReportType_PENDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_DEFAULTED",Swig_var_TradeReportType_DEFAULTED_get, Swig_var_TradeReportType_DEFAULTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_DECLINE",Swig_var_TradeReportType_DECLINE_get, Swig_var_TradeReportType_DECLINE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ALLEGED_NEW",Swig_var_TradeReportType_ALLEGED_NEW_get, Swig_var_TradeReportType_ALLEGED_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ALLEGED_TRADE_REPORT_CANCEL",Swig_var_TradeReportType_ALLEGED_TRADE_REPORT_CANCEL_get, Swig_var_TradeReportType_ALLEGED_TRADE_REPORT_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ALLEGED_15",Swig_var_TradeReportType_ALLEGED_15_get, Swig_var_TradeReportType_ALLEGED_15_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ALLEGED_ADDENDUM",Swig_var_TradeReportType_ALLEGED_ADDENDUM_get, Swig_var_TradeReportType_ALLEGED_ADDENDUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ALLEGED",Swig_var_TradeReportType_ALLEGED_get, Swig_var_TradeReportType_ALLEGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_SUBMIT",Swig_var_TradeReportType_SUBMIT_get, Swig_var_TradeReportType_SUBMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ALLEGED_1",Swig_var_TradeReportType_ALLEGED_1_get, Swig_var_TradeReportType_ALLEGED_1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_INVALID_CMTA",Swig_var_TradeReportType_INVALID_CMTA_get, Swig_var_TradeReportType_INVALID_CMTA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ALLEGED_NO_WAS",Swig_var_TradeReportType_ALLEGED_NO_WAS_get, Swig_var_TradeReportType_ALLEGED_NO_WAS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_TRADE_REPORT_CANCEL",Swig_var_TradeReportType_TRADE_REPORT_CANCEL_get, Swig_var_TradeReportType_TRADE_REPORT_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeReportType_ACCEPT",Swig_var_TradeReportType_ACCEPT_get, Swig_var_TradeReportType_ACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExerciseStyle_AMERICAN",Swig_var_ExerciseStyle_AMERICAN_get, Swig_var_ExerciseStyle_AMERICAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExerciseStyle_EUROPEAN",Swig_var_ExerciseStyle_EUROPEAN_get, Swig_var_ExerciseStyle_EUROPEAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExerciseStyle_BERMUDA",Swig_var_ExerciseStyle_BERMUDA_get, Swig_var_ExerciseStyle_BERMUDA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_ADDITIONAL_INFORMATION",Swig_var_HaltReasonChar_ADDITIONAL_INFORMATION_get, Swig_var_HaltReasonChar_ADDITIONAL_INFORMATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_NEW_PENDING",Swig_var_HaltReasonChar_NEW_PENDING_get, Swig_var_HaltReasonChar_NEW_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_NEWS_PENDING",Swig_var_HaltReasonChar_NEWS_PENDING_get, Swig_var_HaltReasonChar_NEWS_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_ORDER_INFLUX",Swig_var_HaltReasonChar_ORDER_INFLUX_get, Swig_var_HaltReasonChar_ORDER_INFLUX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_NEWS_DISSEMINATION",Swig_var_HaltReasonChar_NEWS_DISSEMINATION_get, Swig_var_HaltReasonChar_NEWS_DISSEMINATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_EQUIPMENT_CHANGEOVER",Swig_var_HaltReasonChar_EQUIPMENT_CHANGEOVER_get, Swig_var_HaltReasonChar_EQUIPMENT_CHANGEOVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HaltReasonChar_ORDER_IMBALANCE",Swig_var_HaltReasonChar_ORDER_IMBALANCE_get, Swig_var_HaltReasonChar_ORDER_IMBALANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExDestination_POSIT",Swig_var_ExDestination_POSIT_get, Swig_var_ExDestination_POSIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExDestination_NONE",Swig_var_ExDestination_NONE_get, Swig_var_ExDestination_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY",Swig_var_AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get, Swig_var_AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_WAREHOUSE_RECAP",Swig_var_AllocReportType_WAREHOUSE_RECAP_get, Swig_var_AllocReportType_WAREHOUSE_RECAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_REJECT",Swig_var_AllocReportType_REJECT_get, Swig_var_AllocReportType_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_ACCEPT_PENDING",Swig_var_AllocReportType_ACCEPT_PENDING_get, Swig_var_AllocReportType_ACCEPT_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_COMPLETE",Swig_var_AllocReportType_COMPLETE_get, Swig_var_AllocReportType_COMPLETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_REQUEST_TO_INTERMEDIARY",Swig_var_AllocReportType_REQUEST_TO_INTERMEDIARY_get, Swig_var_AllocReportType_REQUEST_TO_INTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY",Swig_var_AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY_get, Swig_var_AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY",Swig_var_AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get, Swig_var_AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_REVERSE_PENDING",Swig_var_AllocReportType_REVERSE_PENDING_get, Swig_var_AllocReportType_REVERSE_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocReportType_ACCEPT",Swig_var_AllocReportType_ACCEPT_get, Swig_var_AllocReportType_ACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY",Swig_var_AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_get, Swig_var_AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_INCOMPLETE_GROUP",Swig_var_AllocType_INCOMPLETE_GROUP_get, Swig_var_AllocType_INCOMPLETE_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_REVERSAL_PENDING",Swig_var_AllocType_REVERSAL_PENDING_get, Swig_var_AllocType_REVERSAL_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_CALCULATED",Swig_var_AllocType_CALCULATED_get, Swig_var_AllocType_CALCULATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_REJECT",Swig_var_AllocType_REJECT_get, Swig_var_AllocType_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_PRELIMINARY",Swig_var_AllocType_PRELIMINARY_get, Swig_var_AllocType_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_ACCEPT_PENDING",Swig_var_AllocType_ACCEPT_PENDING_get, Swig_var_AllocType_ACCEPT_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_BUYSIDE_CALCULATED",Swig_var_AllocType_BUYSIDE_CALCULATED_get, Swig_var_AllocType_BUYSIDE_CALCULATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_REQUEST_TO_INTERMEDIARY",Swig_var_AllocType_REQUEST_TO_INTERMEDIARY_get, Swig_var_AllocType_REQUEST_TO_INTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_BUYSIDE_READY_TO_BOOK_5",Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_5_get, Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_BUYSIDE_READY_TO_BOOK_6",Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_6_get, Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_6_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_COMPLETE_GROUP",Swig_var_AllocType_COMPLETE_GROUP_get, Swig_var_AllocType_COMPLETE_GROUP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY",Swig_var_AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY_get, Swig_var_AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_BUYSIDE_READY_TO_BOOK",Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_get, Swig_var_AllocType_BUYSIDE_READY_TO_BOOK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_READY_TO_BOOK",Swig_var_AllocType_READY_TO_BOOK_get, Swig_var_AllocType_READY_TO_BOOK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_WAREHOUSE_INSTRUCTION",Swig_var_AllocType_WAREHOUSE_INSTRUCTION_get, Swig_var_AllocType_WAREHOUSE_INSTRUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_BUYSIDE_PRELIMINARY",Swig_var_AllocType_BUYSIDE_PRELIMINARY_get, Swig_var_AllocType_BUYSIDE_PRELIMINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocType_ACCEPT",Swig_var_AllocType_ACCEPT_get, Swig_var_AllocType_ACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_INSUFFICIENT_CREDIT",Swig_var_QuoteRequestRejectReason_INSUFFICIENT_CREDIT_get, Swig_var_QuoteRequestRejectReason_INSUFFICIENT_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE",Swig_var_QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE_get, Swig_var_QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_INVALID_PRICE",Swig_var_QuoteRequestRejectReason_INVALID_PRICE_get, Swig_var_QuoteRequestRejectReason_INVALID_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_TOO_LATE_TO_ENTER",Swig_var_QuoteRequestRejectReason_TOO_LATE_TO_ENTER_get, Swig_var_QuoteRequestRejectReason_TOO_LATE_TO_ENTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY",Swig_var_QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY_get, Swig_var_QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_EXCHANGE",Swig_var_QuoteRequestRejectReason_EXCHANGE_get, Swig_var_QuoteRequestRejectReason_EXCHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT",Swig_var_QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT_get, Swig_var_QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_UNKNOWN_SYMBOL",Swig_var_QuoteRequestRejectReason_UNKNOWN_SYMBOL_get, Swig_var_QuoteRequestRejectReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_OTHER",Swig_var_QuoteRequestRejectReason_OTHER_get, Swig_var_QuoteRequestRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_PASS",Swig_var_QuoteRequestRejectReason_PASS_get, Swig_var_QuoteRequestRejectReason_PASS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_NO_INVENTORY",Swig_var_QuoteRequestRejectReason_NO_INVENTORY_get, Swig_var_QuoteRequestRejectReason_NO_INVENTORY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT",Swig_var_QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_get, Swig_var_QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LiquidityIndType_20_DAY_MOVING_AVERAGE",Swig_var_LiquidityIndType_20_DAY_MOVING_AVERAGE_get, Swig_var_LiquidityIndType_20_DAY_MOVING_AVERAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LiquidityIndType_5_DAY_MOVING_AVERAGE",Swig_var_LiquidityIndType_5_DAY_MOVING_AVERAGE_get, Swig_var_LiquidityIndType_5_DAY_MOVING_AVERAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LiquidityIndType_5DAY_MOVING_AVERAGE",Swig_var_LiquidityIndType_5DAY_MOVING_AVERAGE_get, Swig_var_LiquidityIndType_5DAY_MOVING_AVERAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LiquidityIndType_NORMAL_MARKET_SIZE",Swig_var_LiquidityIndType_NORMAL_MARKET_SIZE_get, Swig_var_LiquidityIndType_NORMAL_MARKET_SIZE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LiquidityIndType_OTHER",Swig_var_LiquidityIndType_OTHER_get, Swig_var_LiquidityIndType_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatusValue_IN_PROCESS",Swig_var_StatusValue_IN_PROCESS_get, Swig_var_StatusValue_IN_PROCESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatusValue_NOT_CONNECTED_DOWN_EXPECTED_DOWN",Swig_var_StatusValue_NOT_CONNECTED_DOWN_EXPECTED_DOWN_get, Swig_var_StatusValue_NOT_CONNECTED_DOWN_EXPECTED_DOWN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatusValue_NOT_CONNECTED_2",Swig_var_StatusValue_NOT_CONNECTED_2_get, Swig_var_StatusValue_NOT_CONNECTED_2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatusValue_NOT_CONNECTED_DOWN_EXPECTED_UP",Swig_var_StatusValue_NOT_CONNECTED_DOWN_EXPECTED_UP_get, Swig_var_StatusValue_NOT_CONNECTED_DOWN_EXPECTED_UP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatusValue_CONNECTED",Swig_var_StatusValue_CONNECTED_get, Swig_var_StatusValue_CONNECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StatusValue_NOT_CONNECTED_3",Swig_var_StatusValue_NOT_CONNECTED_3_get, Swig_var_StatusValue_NOT_CONNECTED_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_EXCHANGE_FOR_PHYSICAL_QTY",Swig_var_PosType_EXCHANGE_FOR_PHYSICAL_QTY_get, Swig_var_PosType_EXCHANGE_FOR_PHYSICAL_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TRANSFER_TRADE_QTY",Swig_var_PosType_TRANSFER_TRADE_QTY_get, Swig_var_PosType_TRANSFER_TRADE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_INTER_SPREAD_QTY",Swig_var_PosType_INTER_SPREAD_QTY_get, Swig_var_PosType_INTER_SPREAD_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_INTRA_SPREAD_QTY",Swig_var_PosType_INTRA_SPREAD_QTY_get, Swig_var_PosType_INTRA_SPREAD_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_START_OF_DAY_QTY",Swig_var_PosType_START_OF_DAY_QTY_get, Swig_var_PosType_START_OF_DAY_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_DELIVERY_QTY",Swig_var_PosType_DELIVERY_QTY_get, Swig_var_PosType_DELIVERY_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_PIT_TRADE_QTY",Swig_var_PosType_PIT_TRADE_QTY_get, Swig_var_PosType_PIT_TRADE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TRANSACTION_FROM_ASSIGNMENT",Swig_var_PosType_TRANSACTION_FROM_ASSIGNMENT_get, Swig_var_PosType_TRANSACTION_FROM_ASSIGNMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TRANSACTION_FROM_EXERCISE",Swig_var_PosType_TRANSACTION_FROM_EXERCISE_get, Swig_var_PosType_TRANSACTION_FROM_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_OPTION_ASSIGNMENT",Swig_var_PosType_OPTION_ASSIGNMENT_get, Swig_var_PosType_OPTION_ASSIGNMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_AS_OF_TRADE_QTY",Swig_var_PosType_AS_OF_TRADE_QTY_get, Swig_var_PosType_AS_OF_TRADE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_ELECTRONIC_TRADE_QTY",Swig_var_PosType_ELECTRONIC_TRADE_QTY_get, Swig_var_PosType_ELECTRONIC_TRADE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_SUCCESSION_EVENT_ADJUSTMENT",Swig_var_PosType_SUCCESSION_EVENT_ADJUSTMENT_get, Swig_var_PosType_SUCCESSION_EVENT_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_OPTION_EXERCISE_QTY",Swig_var_PosType_OPTION_EXERCISE_QTY_get, Swig_var_PosType_OPTION_EXERCISE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TRANSACTION_QUANTITY",Swig_var_PosType_TRANSACTION_QUANTITY_get, Swig_var_PosType_TRANSACTION_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_NET_DELTA_QTY",Swig_var_PosType_NET_DELTA_QTY_get, Swig_var_PosType_NET_DELTA_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_DELIVERY_NOTICE_QTY",Swig_var_PosType_DELIVERY_NOTICE_QTY_get, Swig_var_PosType_DELIVERY_NOTICE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_TOTAL_TRANSACTION_QTY",Swig_var_PosType_TOTAL_TRANSACTION_QTY_get, Swig_var_PosType_TOTAL_TRANSACTION_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_ADJUSTMENT_QTY",Swig_var_PosType_ADJUSTMENT_QTY_get, Swig_var_PosType_ADJUSTMENT_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_END_OF_DAY_QTY",Swig_var_PosType_END_OF_DAY_QTY_get, Swig_var_PosType_END_OF_DAY_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_RECEIVE_QUANTITY",Swig_var_PosType_RECEIVE_QUANTITY_get, Swig_var_PosType_RECEIVE_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_CREDIT_EVENT_ADJUSTMENT",Swig_var_PosType_CREDIT_EVENT_ADJUSTMENT_get, Swig_var_PosType_CREDIT_EVENT_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_PRIVATELY_NEGOTIATED_TRADE_QTY",Swig_var_PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_get, Swig_var_PosType_PRIVATELY_NEGOTIATED_TRADE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_CORPORATE_ACTION_ADJUSTMENT",Swig_var_PosType_CORPORATE_ACTION_ADJUSTMENT_get, Swig_var_PosType_CORPORATE_ACTION_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_CROSS_MARGIN_QTY",Swig_var_PosType_CROSS_MARGIN_QTY_get, Swig_var_PosType_CROSS_MARGIN_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_INTEGRAL_SPLIT",Swig_var_PosType_INTEGRAL_SPLIT_get, Swig_var_PosType_INTEGRAL_SPLIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosType_ALLOCATION_TRADE_QTY",Swig_var_PosType_ALLOCATION_TRADE_QTY_get, Swig_var_PosType_ALLOCATION_TRADE_QTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnAckType_ASSIGNMENT_REJECTED",Swig_var_StreamAsgnAckType_ASSIGNMENT_REJECTED_get, Swig_var_StreamAsgnAckType_ASSIGNMENT_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StreamAsgnAckType_ASSIGNMENT_ACCEPTED",Swig_var_StreamAsgnAckType_ASSIGNMENT_ACCEPTED_get, Swig_var_StreamAsgnAckType_ASSIGNMENT_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeBasis_ABSOLUTE",Swig_var_MiscFeeBasis_ABSOLUTE_get, Swig_var_MiscFeeBasis_ABSOLUTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeBasis_PERCENTAGE",Swig_var_MiscFeeBasis_PERCENTAGE_get, Swig_var_MiscFeeBasis_PERCENTAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MiscFeeBasis_PER_UNIT",Swig_var_MiscFeeBasis_PER_UNIT_get, Swig_var_MiscFeeBasis_PER_UNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_MARKET",Swig_var_OrdType_FOREX_MARKET_get, Swig_var_OrdType_FOREX_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_PREVIOUSLY_QUOTED",Swig_var_OrdType_FOREX_PREVIOUSLY_QUOTED_get, Swig_var_OrdType_FOREX_PREVIOUSLY_QUOTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_PREVIOUS_FUND_VALUATION_POINT",Swig_var_OrdType_PREVIOUS_FUND_VALUATION_POINT_get, Swig_var_OrdType_PREVIOUS_FUND_VALUATION_POINT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_PEGGED",Swig_var_OrdType_PEGGED_get, Swig_var_OrdType_PEGGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_LIMIT_WITH_OR_WITHOUT",Swig_var_OrdType_LIMIT_WITH_OR_WITHOUT_get, Swig_var_OrdType_LIMIT_WITH_OR_WITHOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_STOP_LIMIT",Swig_var_OrdType_STOP_LIMIT_get, Swig_var_OrdType_STOP_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_SWAP",Swig_var_OrdType_FOREX_SWAP_get, Swig_var_OrdType_FOREX_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT",Swig_var_OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT_get, Swig_var_OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_PREVIOUSLY_QUOTED",Swig_var_OrdType_PREVIOUSLY_QUOTED_get, Swig_var_OrdType_PREVIOUSLY_QUOTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_COUNTER_ORDER_SELECTION",Swig_var_OrdType_COUNTER_ORDER_SELECTION_get, Swig_var_OrdType_COUNTER_ORDER_SELECTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_MARKET_IF_TOUCHED",Swig_var_OrdType_MARKET_IF_TOUCHED_get, Swig_var_OrdType_MARKET_IF_TOUCHED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_NEXT_FUND_VALUATION_POINT",Swig_var_OrdType_NEXT_FUND_VALUATION_POINT_get, Swig_var_OrdType_NEXT_FUND_VALUATION_POINT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_C",Swig_var_OrdType_FOREX_C_get, Swig_var_OrdType_FOREX_C_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_ON_CLOSE",Swig_var_OrdType_ON_CLOSE_get, Swig_var_OrdType_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_STOP",Swig_var_OrdType_STOP_get, Swig_var_OrdType_STOP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_LIMIT",Swig_var_OrdType_FOREX_LIMIT_get, Swig_var_OrdType_FOREX_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX",Swig_var_OrdType_FOREX_get, Swig_var_OrdType_FOREX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FUNARI",Swig_var_OrdType_FUNARI_get, Swig_var_OrdType_FUNARI_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_F",Swig_var_OrdType_FOREX_F_get, Swig_var_OrdType_FOREX_F_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_PREVIOUSLY_INDICATED",Swig_var_OrdType_PREVIOUSLY_INDICATED_get, Swig_var_OrdType_PREVIOUSLY_INDICATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_WITH_OR_WITHOUT",Swig_var_OrdType_WITH_OR_WITHOUT_get, Swig_var_OrdType_WITH_OR_WITHOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_MARKET_ON_CLOSE",Swig_var_OrdType_MARKET_ON_CLOSE_get, Swig_var_OrdType_MARKET_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_LIMIT",Swig_var_OrdType_LIMIT_get, Swig_var_OrdType_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT",Swig_var_OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT_get, Swig_var_OrdType_MARKET_WITH_LEFTOVER_AS_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_G",Swig_var_OrdType_FOREX_G_get, Swig_var_OrdType_FOREX_G_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_LIMIT_ON_CLOSE",Swig_var_OrdType_LIMIT_ON_CLOSE_get, Swig_var_OrdType_LIMIT_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_FOREX_H",Swig_var_OrdType_FOREX_H_get, Swig_var_OrdType_FOREX_H_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_ON_BASIS",Swig_var_OrdType_ON_BASIS_get, Swig_var_OrdType_ON_BASIS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_LIMIT_OR_BETTER",Swig_var_OrdType_LIMIT_OR_BETTER_get, Swig_var_OrdType_LIMIT_OR_BETTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OrdType_MARKET",Swig_var_OrdType_MARKET_get, Swig_var_OrdType_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS",Swig_var_MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS_get, Swig_var_MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED",Swig_var_MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get, Swig_var_MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_NON_ACT",Swig_var_MatchType_NON_ACT_get, Swig_var_MatchType_NON_ACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND",Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_get, Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3",Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3_get, Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_AUTO_MATCH",Swig_var_MatchType_AUTO_MATCH_get, Swig_var_MatchType_AUTO_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES",Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_get, Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED",Swig_var_MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get, Swig_var_MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4",Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4_get, Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CALL_AUCTION",Swig_var_MatchType_CALL_AUCTION_get, Swig_var_MatchType_CALL_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED",Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED_get, Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED",Swig_var_MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get, Swig_var_MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST",Swig_var_MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_get, Swig_var_MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES",Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_get, Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ACT_M2_MATCH",Swig_var_MatchType_ACT_M2_MATCH_get, Swig_var_MatchType_ACT_M2_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5",Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5_get, Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ONE_PARTY_TRADE_REPORT",Swig_var_MatchType_ONE_PARTY_TRADE_REPORT_get, Swig_var_MatchType_ONE_PARTY_TRADE_REPORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ACT_M1_MATCH",Swig_var_MatchType_ACT_M1_MATCH_get, Swig_var_MatchType_ACT_M1_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_COUNTER_ORDER_SELECTION",Swig_var_MatchType_COUNTER_ORDER_SELECTION_get, Swig_var_MatchType_COUNTER_ORDER_SELECTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ISSUING_BUY_BACK_AUCTION",Swig_var_MatchType_ISSUING_BUY_BACK_AUCTION_get, Swig_var_MatchType_ISSUING_BUY_BACK_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT",Swig_var_MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get, Swig_var_MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CROSS_AUCTION_63",Swig_var_MatchType_CROSS_AUCTION_63_get, Swig_var_MatchType_CROSS_AUCTION_63_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CROSS_AUCTION_5",Swig_var_MatchType_CROSS_AUCTION_5_get, Swig_var_MatchType_CROSS_AUCTION_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CALL_AUCTION_7",Swig_var_MatchType_CALL_AUCTION_7_get, Swig_var_MatchType_CALL_AUCTION_7_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_COUNTER_ORDER_SELECTION_64",Swig_var_MatchType_COUNTER_ORDER_SELECTION_64_get, Swig_var_MatchType_COUNTER_ORDER_SELECTION_64_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_TWO_PARTY_TRADE_REPORT",Swig_var_MatchType_TWO_PARTY_TRADE_REPORT_get, Swig_var_MatchType_TWO_PARTY_TRADE_REPORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH",Swig_var_MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH_get, Swig_var_MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_AND_EXECUTION_TIME",Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_AND_EXECUTION_TIME_get, Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_AND_EXECUTION_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ACT_DEFAULT_TRADE",Swig_var_MatchType_ACT_DEFAULT_TRADE_get, Swig_var_MatchType_ACT_DEFAULT_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ACT_ACCEPTED_TRADE",Swig_var_MatchType_ACT_ACCEPTED_TRADE_get, Swig_var_MatchType_ACT_ACCEPTED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_COUNTER_ORDER_SELECTION_6",Swig_var_MatchType_COUNTER_ORDER_SELECTION_6_get, Swig_var_MatchType_COUNTER_ORDER_SELECTION_6_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED",Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get, Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_AND_EXECUTION_TIME",Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_AND_EXECUTION_TIME_get, Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_AND_EXECUTION_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADETYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME",Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADETYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME_get, Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADETYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CROSS_AUCTION",Swig_var_MatchType_CROSS_AUCTION_get, Swig_var_MatchType_CROSS_AUCTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CALL_AUCTION_65",Swig_var_MatchType_CALL_AUCTION_65_get, Swig_var_MatchType_CALL_AUCTION_65_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CONFIRMED_TRADE_REPORT",Swig_var_MatchType_CONFIRMED_TRADE_REPORT_get, Swig_var_MatchType_CONFIRMED_TRADE_REPORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED",Swig_var_MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_get, Swig_var_MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ACT_M6_MATCH",Swig_var_MatchType_ACT_M6_MATCH_get, Swig_var_MatchType_ACT_M6_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT",Swig_var_MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_get, Swig_var_MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_CONTINUOUS_AUTO_MATCH",Swig_var_MatchType_CONTINUOUS_AUTO_MATCH_get, Swig_var_MatchType_CONTINUOUS_AUTO_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_OCS_LOCKED_IN_NON_ACT",Swig_var_MatchType_OCS_LOCKED_IN_NON_ACT_get, Swig_var_MatchType_OCS_LOCKED_IN_NON_ACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME",Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME_get, Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1",Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1_get, Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_MINUS_BADGES_AND_TIMES_ACT_M1_MATCH",Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_MINUS_BADGES_AND_TIMES_ACT_M1_MATCH_get, Swig_var_MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_MINUS_BADGES_AND_TIMES_ACT_M1_MATCH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2",Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2_get, Swig_var_MatchType_SUMMARIZED_MATCH_USING_A1_TO_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED_S2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchType_ACT_DEFAULT_AFTER_M2",Swig_var_MatchType_ACT_DEFAULT_AFTER_M2_get, Swig_var_MatchType_ACT_DEFAULT_AFTER_M2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OptPayoutType_BINARY",Swig_var_OptPayoutType_BINARY_get, Swig_var_OptPayoutType_BINARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OptPayoutType_VANILLA",Swig_var_OptPayoutType_VANILLA_get, Swig_var_OptPayoutType_VANILLA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OptPayoutType_CAPPED",Swig_var_OptPayoutType_CAPPED_get, Swig_var_OptPayoutType_CAPPED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MarketUpdateAction_DELETE",Swig_var_MarketUpdateAction_DELETE_get, Swig_var_MarketUpdateAction_DELETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MarketUpdateAction_ADD",Swig_var_MarketUpdateAction_ADD_get, Swig_var_MarketUpdateAction_ADD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MarketUpdateAction_MODIFY",Swig_var_MarketUpdateAction_MODIFY_get, Swig_var_MarketUpdateAction_MODIFY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION",Swig_var_CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_get, Swig_var_CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT",Swig_var_CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT_get, Swig_var_CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_UNKNOWN_DEAL",Swig_var_CollAsgnRejectReason_UNKNOWN_DEAL_get, Swig_var_CollAsgnRejectReason_UNKNOWN_DEAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL",Swig_var_CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL_get, Swig_var_CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_OTHER",Swig_var_CollAsgnRejectReason_OTHER_get, Swig_var_CollAsgnRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION",Swig_var_CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_get, Swig_var_CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAsgnRejectReason_INSUFFICIENT_COLLATERAL",Swig_var_CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_get, Swig_var_CollAsgnRejectReason_INSUFFICIENT_COLLATERAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IndividualAllocType_SUB_ALLOCATE",Swig_var_IndividualAllocType_SUB_ALLOCATE_get, Swig_var_IndividualAllocType_SUB_ALLOCATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IndividualAllocType_THIRD_PARTY_ALLOCATION",Swig_var_IndividualAllocType_THIRD_PARTY_ALLOCATION_get, Swig_var_IndividualAllocType_THIRD_PARTY_ALLOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION",Swig_var_GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION_get, Swig_var_GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE",Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE_get, Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLY_NOTIFIED_OTHERWISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES",Swig_var_GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES_get, Swig_var_GTBookingInst_ACCUMULATE_EXECUTIONS_UNTIL_ORDER_IS_FILLED_OR_EXPIRES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE",Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE_get, Swig_var_GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES",Swig_var_GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES_get, Swig_var_GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PutOrCall_PUT",Swig_var_PutOrCall_PUT_get, Swig_var_PutOrCall_PUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PutOrCall_CALL",Swig_var_PutOrCall_CALL_get, Swig_var_PutOrCall_CALL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FundRenewWaiv_NO",Swig_var_FundRenewWaiv_NO_get, Swig_var_FundRenewWaiv_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FundRenewWaiv_YES",Swig_var_FundRenewWaiv_YES_get, Swig_var_FundRenewWaiv_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ForexReq_NO",Swig_var_ForexReq_NO_get, Swig_var_ForexReq_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ForexReq_YES",Swig_var_ForexReq_YES_get, Swig_var_ForexReq_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickRuleType_TRADED_AS_A_SPREAD_LEG",Swig_var_TickRuleType_TRADED_AS_A_SPREAD_LEG_get, Swig_var_TickRuleType_TRADED_AS_A_SPREAD_LEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickRuleType_REGULAR",Swig_var_TickRuleType_REGULAR_get, Swig_var_TickRuleType_REGULAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickRuleType_VARIABLE",Swig_var_TickRuleType_VARIABLE_get, Swig_var_TickRuleType_VARIABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickRuleType_SETTLED_AS_A_SPREAD_LEG",Swig_var_TickRuleType_SETTLED_AS_A_SPREAD_LEG_get, Swig_var_TickRuleType_SETTLED_AS_A_SPREAD_LEG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TickRuleType_FIXED",Swig_var_TickRuleType_FIXED_get, Swig_var_TickRuleType_FIXED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionOffsetType_PRICE",Swig_var_DiscretionOffsetType_PRICE_get, Swig_var_DiscretionOffsetType_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionOffsetType_PRICE_TIER",Swig_var_DiscretionOffsetType_PRICE_TIER_get, Swig_var_DiscretionOffsetType_PRICE_TIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionOffsetType_TICKS",Swig_var_DiscretionOffsetType_TICKS_get, Swig_var_DiscretionOffsetType_TICKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionOffsetType_BASIS_POINTS",Swig_var_DiscretionOffsetType_BASIS_POINTS_get, Swig_var_DiscretionOffsetType_BASIS_POINTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmTransType_REPLACE",Swig_var_ConfirmTransType_REPLACE_get, Swig_var_ConfirmTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmTransType_NEW",Swig_var_ConfirmTransType_NEW_get, Swig_var_ConfirmTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ConfirmTransType_CANCEL",Swig_var_ConfirmTransType_CANCEL_get, Swig_var_ConfirmTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDSecSizeType_CUSTOMER",Swig_var_MDSecSizeType_CUSTOMER_get, Swig_var_MDSecSizeType_CUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesEvent_CHANGE_OF_TRADING_STATUS",Swig_var_TradSesEvent_CHANGE_OF_TRADING_STATUS_get, Swig_var_TradSesEvent_CHANGE_OF_TRADING_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesEvent_CHANGE_OF_TRADING_SESSION",Swig_var_TradSesEvent_CHANGE_OF_TRADING_SESSION_get, Swig_var_TradSesEvent_CHANGE_OF_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesEvent_CHANGE_OF_TRADING_SUBSESSION",Swig_var_TradSesEvent_CHANGE_OF_TRADING_SUBSESSION_get, Swig_var_TradSesEvent_CHANGE_OF_TRADING_SUBSESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesEvent_TRADING_RESUMES",Swig_var_TradSesEvent_TRADING_RESUMES_get, Swig_var_TradSesEvent_TRADING_RESUMES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DlvyInstType_SECURITIES",Swig_var_DlvyInstType_SECURITIES_get, Swig_var_DlvyInstType_SECURITIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DlvyInstType_CASH",Swig_var_DlvyInstType_CASH_get, Swig_var_DlvyInstType_CASH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_IMPLIED_TRADE",Swig_var_TradeCondition_IMPLIED_TRADE_get, Swig_var_TradeCondition_IMPLIED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OPENING_PRICE",Swig_var_TradeCondition_OPENING_PRICE_get, Swig_var_TradeCondition_OPENING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_PRIOR_REFERENCE_PRICE",Swig_var_TradeCondition_PRIOR_REFERENCE_PRICE_get, Swig_var_TradeCondition_PRIOR_REFERENCE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_LAST_ETH",Swig_var_TradeCondition_CANCEL_LAST_ETH_get, Swig_var_TradeCondition_CANCEL_LAST_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SELLER",Swig_var_TradeCondition_SELLER_get, Swig_var_TradeCondition_SELLER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_DISTRIBUTION",Swig_var_TradeCondition_DISTRIBUTION_get, Swig_var_TradeCondition_DISTRIBUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_NEXT_DAY_TRADE",Swig_var_TradeCondition_NEXT_DAY_TRADE_get, Swig_var_TradeCondition_NEXT_DAY_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_STRADDLE_ETH",Swig_var_TradeCondition_STRADDLE_ETH_get, Swig_var_TradeCondition_STRADDLE_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SPREAD",Swig_var_TradeCondition_SPREAD_get, Swig_var_TradeCondition_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CROSSED_AO",Swig_var_TradeCondition_CROSSED_AO_get, Swig_var_TradeCondition_CROSSED_AO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SOLD_LAST_SALE",Swig_var_TradeCondition_SOLD_LAST_SALE_get, Swig_var_TradeCondition_SOLD_LAST_SALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OPENED_SALE_ETH",Swig_var_TradeCondition_OPENED_SALE_ETH_get, Swig_var_TradeCondition_OPENED_SALE_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_REOPEN_ETH",Swig_var_TradeCondition_REOPEN_ETH_get, Swig_var_TradeCondition_REOPEN_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SOLD_LAST_SALE_ETH",Swig_var_TradeCondition_SOLD_LAST_SALE_ETH_get, Swig_var_TradeCondition_SOLD_LAST_SALE_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_STOPPED_SOLD_LAST",Swig_var_TradeCondition_STOPPED_SOLD_LAST_get, Swig_var_TradeCondition_STOPPED_SOLD_LAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP",Swig_var_TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP_get, Swig_var_TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_FORM_T",Swig_var_TradeCondition_FORM_T_get, Swig_var_TradeCondition_FORM_T_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_ADJUSTED",Swig_var_TradeCondition_ADJUSTED_get, Swig_var_TradeCondition_ADJUSTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_ETH",Swig_var_TradeCondition_CANCEL_ETH_get, Swig_var_TradeCondition_CANCEL_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OUT_OF_SEQUENCE_ETH",Swig_var_TradeCondition_OUT_OF_SEQUENCE_ETH_get, Swig_var_TradeCondition_OUT_OF_SEQUENCE_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_COMBO_ETH",Swig_var_TradeCondition_COMBO_ETH_get, Swig_var_TradeCondition_COMBO_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_ONLY_ETH",Swig_var_TradeCondition_CANCEL_ONLY_ETH_get, Swig_var_TradeCondition_CANCEL_ONLY_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_STRADDLE",Swig_var_TradeCondition_STRADDLE_get, Swig_var_TradeCondition_STRADDLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OUTSIDE_SPREAD",Swig_var_TradeCondition_OUTSIDE_SPREAD_get, Swig_var_TradeCondition_OUTSIDE_SPREAD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_BUNCHED_SALE",Swig_var_TradeCondition_BUNCHED_SALE_get, Swig_var_TradeCondition_BUNCHED_SALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_STOPPED",Swig_var_TradeCondition_CANCEL_STOPPED_get, Swig_var_TradeCondition_CANCEL_STOPPED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_LATE_OPEN_ETH",Swig_var_TradeCondition_LATE_OPEN_ETH_get, Swig_var_TradeCondition_LATE_OPEN_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OPENING_REOPENING_TRADE_DETAIL",Swig_var_TradeCondition_OPENING_REOPENING_TRADE_DETAIL_get, Swig_var_TradeCondition_OPENING_REOPENING_TRADE_DETAIL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL",Swig_var_TradeCondition_CANCEL_get, Swig_var_TradeCondition_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_COMBO",Swig_var_TradeCondition_COMBO_get, Swig_var_TradeCondition_COMBO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OPENING",Swig_var_TradeCondition_OPENING_get, Swig_var_TradeCondition_OPENING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_ACQUISITION",Swig_var_TradeCondition_ACQUISITION_get, Swig_var_TradeCondition_ACQUISITION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OPENED",Swig_var_TradeCondition_OPENED_get, Swig_var_TradeCondition_OPENED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_ONLY",Swig_var_TradeCondition_CANCEL_ONLY_get, Swig_var_TradeCondition_CANCEL_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_NEXT_DAY",Swig_var_TradeCondition_NEXT_DAY_get, Swig_var_TradeCondition_NEXT_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_BARGAIN_CONDITION",Swig_var_TradeCondition_BARGAIN_CONDITION_get, Swig_var_TradeCondition_BARGAIN_CONDITION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_STOPPED",Swig_var_TradeCondition_STOPPED_get, Swig_var_TradeCondition_STOPPED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CONVERTED_PRICE_INDICATOR",Swig_var_TradeCondition_CONVERTED_PRICE_INDICATOR_get, Swig_var_TradeCondition_CONVERTED_PRICE_INDICATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OFFICIAL_CLOSING_PRICE",Swig_var_TradeCondition_OFFICIAL_CLOSING_PRICE_get, Swig_var_TradeCondition_OFFICIAL_CLOSING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_ADJUSTED_ETH",Swig_var_TradeCondition_ADJUSTED_ETH_get, Swig_var_TradeCondition_ADJUSTED_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_RULE_155_TRADE",Swig_var_TradeCondition_RULE_155_TRADE_get, Swig_var_TradeCondition_RULE_155_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_AUTOMATIC_EXECUTION",Swig_var_TradeCondition_AUTOMATIC_EXECUTION_get, Swig_var_TradeCondition_AUTOMATIC_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CROSSED_X",Swig_var_TradeCondition_CROSSED_X_get, Swig_var_TradeCondition_CROSSED_X_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_AUTO_EXECUTION_ETH",Swig_var_TradeCondition_AUTO_EXECUTION_ETH_get, Swig_var_TradeCondition_AUTO_EXECUTION_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_MULTILEG_TO_MULTILEG_TRADE",Swig_var_TradeCondition_MULTILEG_TO_MULTILEG_TRADE_get, Swig_var_TradeCondition_MULTILEG_TO_MULTILEG_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_BASKET_INDEX",Swig_var_TradeCondition_BASKET_INDEX_get, Swig_var_TradeCondition_BASKET_INDEX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE",Swig_var_TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE_get, Swig_var_TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_FINAL_PRICE_OF_SESSION",Swig_var_TradeCondition_FINAL_PRICE_OF_SESSION_get, Swig_var_TradeCondition_FINAL_PRICE_OF_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_STOPPED_STOCK",Swig_var_TradeCondition_STOPPED_STOCK_get, Swig_var_TradeCondition_STOPPED_STOCK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_OFFICAL_CLOSING_PRICE",Swig_var_TradeCondition_OFFICAL_CLOSING_PRICE_get, Swig_var_TradeCondition_OFFICAL_CLOSING_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE",Swig_var_TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE_get, Swig_var_TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CASH",Swig_var_TradeCondition_CASH_get, Swig_var_TradeCondition_CASH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_OPEN",Swig_var_TradeCondition_CANCEL_OPEN_get, Swig_var_TradeCondition_CANCEL_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_REGULAR_ETH",Swig_var_TradeCondition_REGULAR_ETH_get, Swig_var_TradeCondition_REGULAR_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_STOPPED_ETH",Swig_var_TradeCondition_STOPPED_ETH_get, Swig_var_TradeCondition_STOPPED_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_VOLUME_ONLY",Swig_var_TradeCondition_VOLUME_ONLY_get, Swig_var_TradeCondition_VOLUME_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_STOPPED_ETH",Swig_var_TradeCondition_CANCEL_STOPPED_ETH_get, Swig_var_TradeCondition_CANCEL_STOPPED_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_STOPPED_OUT_OF_SEQUENCE",Swig_var_TradeCondition_STOPPED_OUT_OF_SEQUENCE_get, Swig_var_TradeCondition_STOPPED_OUT_OF_SEQUENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CASH_TRADE",Swig_var_TradeCondition_CASH_TRADE_get, Swig_var_TradeCondition_CASH_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SPLIT_TRADE",Swig_var_TradeCondition_SPLIT_TRADE_get, Swig_var_TradeCondition_SPLIT_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_IMBALANCE_MORE_BUYERS",Swig_var_TradeCondition_IMBALANCE_MORE_BUYERS_get, Swig_var_TradeCondition_IMBALANCE_MORE_BUYERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_IMBALANCE_MORE_SELLERS",Swig_var_TradeCondition_IMBALANCE_MORE_SELLERS_get, Swig_var_TradeCondition_IMBALANCE_MORE_SELLERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_INTRADAY_TRADE_DETAIL",Swig_var_TradeCondition_INTRADAY_TRADE_DETAIL_get, Swig_var_TradeCondition_INTRADAY_TRADE_DETAIL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_RULE_127_TRADE",Swig_var_TradeCondition_RULE_127_TRADE_get, Swig_var_TradeCondition_RULE_127_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_BUNCHED",Swig_var_TradeCondition_BUNCHED_get, Swig_var_TradeCondition_BUNCHED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_REOPEN",Swig_var_TradeCondition_REOPEN_get, Swig_var_TradeCondition_REOPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_EX_PIT",Swig_var_TradeCondition_EX_PIT_get, Swig_var_TradeCondition_EX_PIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_DIRECT_PLUS",Swig_var_TradeCondition_DIRECT_PLUS_get, Swig_var_TradeCondition_DIRECT_PLUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_LAST",Swig_var_TradeCondition_CANCEL_LAST_get, Swig_var_TradeCondition_CANCEL_LAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_AVERAGE_PRICE_TRADE",Swig_var_TradeCondition_AVERAGE_PRICE_TRADE_get, Swig_var_TradeCondition_AVERAGE_PRICE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SOLD_LAST",Swig_var_TradeCondition_SOLD_LAST_get, Swig_var_TradeCondition_SOLD_LAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_MARKETPLACE_ENTERED_TRADE",Swig_var_TradeCondition_MARKETPLACE_ENTERED_TRADE_get, Swig_var_TradeCondition_MARKETPLACE_ENTERED_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SPREAD_ETH",Swig_var_TradeCondition_SPREAD_ETH_get, Swig_var_TradeCondition_SPREAD_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_CANCEL_OPEN_ETH",Swig_var_TradeCondition_CANCEL_OPEN_ETH_get, Swig_var_TradeCondition_CANCEL_OPEN_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_EXCHANGE_LAST",Swig_var_TradeCondition_EXCHANGE_LAST_get, Swig_var_TradeCondition_EXCHANGE_LAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_FAST_MARKET",Swig_var_TradeCondition_FAST_MARKET_get, Swig_var_TradeCondition_FAST_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_BURST_BASKET",Swig_var_TradeCondition_BURST_BASKET_get, Swig_var_TradeCondition_BURST_BASKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeCondition_SOLD",Swig_var_TradeCondition_SOLD_get, Swig_var_TradeCondition_SOLD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceLimitType_PRICE",Swig_var_PriceLimitType_PRICE_get, Swig_var_PriceLimitType_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceLimitType_TICKS",Swig_var_PriceLimitType_TICKS_get, Swig_var_PriceLimitType_TICKS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriceLimitType_PERCENTAGE",Swig_var_PriceLimitType_PERCENTAGE_get, Swig_var_PriceLimitType_PERCENTAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PER_SHARE",Swig_var_CommType_PER_SHARE_get, Swig_var_CommType_PER_SHARE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_POINTS_PER_BOND_OR_CONTRACT_SUPPLY_CONTRACTMULTIPLIER",Swig_var_CommType_POINTS_PER_BOND_OR_CONTRACT_SUPPLY_CONTRACTMULTIPLIER_get, Swig_var_CommType_POINTS_PER_BOND_OR_CONTRACT_SUPPLY_CONTRACTMULTIPLIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_ABSOLUTE",Swig_var_CommType_ABSOLUTE_get, Swig_var_CommType_ABSOLUTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PER_BOND",Swig_var_CommType_PER_BOND_get, Swig_var_CommType_PER_BOND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PERCENTAGE",Swig_var_CommType_PERCENTAGE_get, Swig_var_CommType_PERCENTAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PERCENTAGE_WAIVED_4",Swig_var_CommType_PERCENTAGE_WAIVED_4_get, Swig_var_CommType_PERCENTAGE_WAIVED_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_POINTS_PER_BOND_OR_CONTRACT",Swig_var_CommType_POINTS_PER_BOND_OR_CONTRACT_get, Swig_var_CommType_POINTS_PER_BOND_OR_CONTRACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PERCENTAGE_WAIVED_5",Swig_var_CommType_PERCENTAGE_WAIVED_5_get, Swig_var_CommType_PERCENTAGE_WAIVED_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PER_UNIT",Swig_var_CommType_PER_UNIT_get, Swig_var_CommType_PER_UNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_PERCENT",Swig_var_CommType_PERCENT_get, Swig_var_CommType_PERCENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_4",Swig_var_CommType_4_get, Swig_var_CommType_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CommType_5",Swig_var_CommType_5_get, Swig_var_CommType_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DTLS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE",Swig_var_RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE_get, Swig_var_RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_SOURCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETLS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_OTHER",Swig_var_RegistRejReasonCode_OTHER_get, Swig_var_RegistRejReasonCode_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DTLS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS",Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS_get, Swig_var_RegistRejReasonCode_INVALID_UNACCEPTABLE_NODISTRIBINSTNS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FinancialStatus_BANKRUPT",Swig_var_FinancialStatus_BANKRUPT_get, Swig_var_FinancialStatus_BANKRUPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FinancialStatus_RESTRICTED",Swig_var_FinancialStatus_RESTRICTED_get, Swig_var_FinancialStatus_RESTRICTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FinancialStatus_PENDING_DELISTING",Swig_var_FinancialStatus_PENDING_DELISTING_get, Swig_var_FinancialStatus_PENDING_DELISTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastFragment_NO",Swig_var_LastFragment_NO_get, Swig_var_LastFragment_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastFragment_YES",Swig_var_LastFragment_YES_get, Swig_var_LastFragment_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NotifyBrokerOfCredit_NO",Swig_var_NotifyBrokerOfCredit_NO_get, Swig_var_NotifyBrokerOfCredit_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NotifyBrokerOfCredit_YES",Swig_var_NotifyBrokerOfCredit_YES_get, Swig_var_NotifyBrokerOfCredit_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_DEPARTMENT",Swig_var_PartySubIDType_DEPARTMENT_get, Swig_var_PartySubIDType_DEPARTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_FAX_NUMBER",Swig_var_PartySubIDType_FAX_NUMBER_get, Swig_var_PartySubIDType_FAX_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_CASH_ACCOUNT_NUMBER",Swig_var_PartySubIDType_CASH_ACCOUNT_NUMBER_get, Swig_var_PartySubIDType_CASH_ACCOUNT_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGISTERED_ADDRESS_12",Swig_var_PartySubIDType_REGISTERED_ADDRESS_12_get, Swig_var_PartySubIDType_REGISTERED_ADDRESS_12_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_CONTACT_NAME",Swig_var_PartySubIDType_CONTACT_NAME_get, Swig_var_PartySubIDType_CONTACT_NAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_PERSON",Swig_var_PartySubIDType_PERSON_get, Swig_var_PartySubIDType_PERSON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_FIRM",Swig_var_PartySubIDType_FIRM_get, Swig_var_PartySubIDType_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_SECURITY_LOCATE_ID",Swig_var_PartySubIDType_SECURITY_LOCATE_ID_get, Swig_var_PartySubIDType_SECURITY_LOCATE_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_POSITION_ACCOUNT_TYPE",Swig_var_PartySubIDType_POSITION_ACCOUNT_TYPE_get, Swig_var_PartySubIDType_POSITION_ACCOUNT_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_CASH_ACCOUNT_NAME",Swig_var_PartySubIDType_CASH_ACCOUNT_NAME_get, Swig_var_PartySubIDType_CASH_ACCOUNT_NAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_POSTAL_ADDRESS",Swig_var_PartySubIDType_POSTAL_ADDRESS_get, Swig_var_PartySubIDType_POSTAL_ADDRESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_PROFESSIONAL_CLIENT",Swig_var_PartySubIDType_PROFESSIONAL_CLIENT_get, Swig_var_PartySubIDType_PROFESSIONAL_CLIENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_LOCATION",Swig_var_PartySubIDType_LOCATION_get, Swig_var_PartySubIDType_LOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_FUND_ACCOUNT_NAME",Swig_var_PartySubIDType_FUND_ACCOUNT_NAME_get, Swig_var_PartySubIDType_FUND_ACCOUNT_NAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGISTRATION_NUMBER",Swig_var_PartySubIDType_REGISTRATION_NUMBER_get, Swig_var_PartySubIDType_REGISTRATION_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_SYSTEM",Swig_var_PartySubIDType_SYSTEM_get, Swig_var_PartySubIDType_SYSTEM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE",Swig_var_PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE_get, Swig_var_PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGULATORY_STATUS",Swig_var_PartySubIDType_REGULATORY_STATUS_get, Swig_var_PartySubIDType_REGULATORY_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER",Swig_var_PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER_get, Swig_var_PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_TELEX_NUMBER",Swig_var_PartySubIDType_TELEX_NUMBER_get, Swig_var_PartySubIDType_TELEX_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGISTERED_ADDRESS_18",Swig_var_PartySubIDType_REGISTERED_ADDRESS_18_get, Swig_var_PartySubIDType_REGISTERED_ADDRESS_18_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_BIC",Swig_var_PartySubIDType_BIC_get, Swig_var_PartySubIDType_BIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_REGISTRATION_NAME",Swig_var_PartySubIDType_REGISTRATION_NAME_get, Swig_var_PartySubIDType_REGISTRATION_NAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_EMAIL_ADDRESS",Swig_var_PartySubIDType_EMAIL_ADDRESS_get, Swig_var_PartySubIDType_EMAIL_ADDRESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_LOCATION_DESK",Swig_var_PartySubIDType_LOCATION_DESK_get, Swig_var_PartySubIDType_LOCATION_DESK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_APPLICATION",Swig_var_PartySubIDType_APPLICATION_get, Swig_var_PartySubIDType_APPLICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_SECURITIES_ACCOUNT_NAME",Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NAME_get, Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_PHONE_NUMBER",Swig_var_PartySubIDType_PHONE_NUMBER_get, Swig_var_PartySubIDType_PHONE_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_ELIGIBLE_COUNTERPARTY",Swig_var_PartySubIDType_ELIGIBLE_COUNTERPARTY_get, Swig_var_PartySubIDType_ELIGIBLE_COUNTERPARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_MARKET_MAKER",Swig_var_PartySubIDType_MARKET_MAKER_get, Swig_var_PartySubIDType_MARKET_MAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_EXECUTION_VENUE",Swig_var_PartySubIDType_EXECUTION_VENUE_get, Swig_var_PartySubIDType_EXECUTION_VENUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_SECURITIES_ACCOUNT_NUMBER",Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NUMBER_get, Swig_var_PartySubIDType_SECURITIES_ACCOUNT_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartySubIDType_FULL_LEGAL_NAME_OF_FIRM",Swig_var_PartySubIDType_FULL_LEGAL_NAME_OF_FIRM_get, Swig_var_PartySubIDType_FULL_LEGAL_NAME_OF_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocNoOrdersType_EXPLICIT_LIST_PROVIDED",Swig_var_AllocNoOrdersType_EXPLICIT_LIST_PROVIDED_get, Swig_var_AllocNoOrdersType_EXPLICIT_LIST_PROVIDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocNoOrdersType_NOT_SPECIFIED",Swig_var_AllocNoOrdersType_NOT_SPECIFIED_get, Swig_var_AllocNoOrdersType_NOT_SPECIFIED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocLinkType_FX_SWAP",Swig_var_AllocLinkType_FX_SWAP_get, Swig_var_AllocLinkType_FX_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocLinkType_F_X_NETTING",Swig_var_AllocLinkType_F_X_NETTING_get, Swig_var_AllocLinkType_F_X_NETTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocLinkType_FX_NETTING",Swig_var_AllocLinkType_FX_NETTING_get, Swig_var_AllocLinkType_FX_NETTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocLinkType_F_X_SWAP",Swig_var_AllocLinkType_F_X_SWAP_get, Swig_var_AllocLinkType_F_X_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingSettlementType_T_PLUS_1",Swig_var_UnderlyingSettlementType_T_PLUS_1_get, Swig_var_UnderlyingSettlementType_T_PLUS_1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingSettlementType_T_PLUS_3",Swig_var_UnderlyingSettlementType_T_PLUS_3_get, Swig_var_UnderlyingSettlementType_T_PLUS_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingSettlementType_T_PLUS_4",Swig_var_UnderlyingSettlementType_T_PLUS_4_get, Swig_var_UnderlyingSettlementType_T_PLUS_4_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DisplayMethod_NEW",Swig_var_DisplayMethod_NEW_get, Swig_var_DisplayMethod_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DisplayMethod_UNDISCLOSED",Swig_var_DisplayMethod_UNDISCLOSED_get, Swig_var_DisplayMethod_UNDISCLOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DisplayMethod_RANDOM",Swig_var_DisplayMethod_RANDOM_get, Swig_var_DisplayMethod_RANDOM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DisplayMethod_INITIAL",Swig_var_DisplayMethod_INITIAL_get, Swig_var_DisplayMethod_INITIAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollStatus_PARTIALLY_ASSIGNED",Swig_var_CollStatus_PARTIALLY_ASSIGNED_get, Swig_var_CollStatus_PARTIALLY_ASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollStatus_ASSIGNMENT_PROPOSED",Swig_var_CollStatus_ASSIGNMENT_PROPOSED_get, Swig_var_CollStatus_ASSIGNMENT_PROPOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollStatus_CHALLENGED",Swig_var_CollStatus_CHALLENGED_get, Swig_var_CollStatus_CHALLENGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollStatus_ASSIGNED",Swig_var_CollStatus_ASSIGNED_get, Swig_var_CollStatus_ASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollStatus_UNASSIGNED",Swig_var_CollStatus_UNASSIGNED_get, Swig_var_CollStatus_UNASSIGNED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideValueInd_SIDEVALUE_2",Swig_var_SideValueInd_SIDEVALUE_2_get, Swig_var_SideValueInd_SIDEVALUE_2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideValueInd_SIDEVALUE1",Swig_var_SideValueInd_SIDEVALUE1_get, Swig_var_SideValueInd_SIDEVALUE1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideValueInd_SIDE_VALUE_1",Swig_var_SideValueInd_SIDE_VALUE_1_get, Swig_var_SideValueInd_SIDE_VALUE_1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SideValueInd_SIDE_VALUE_2",Swig_var_SideValueInd_SIDE_VALUE_2_get, Swig_var_SideValueInd_SIDE_VALUE_2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgDirection_RECEIVE",Swig_var_MsgDirection_RECEIVE_get, Swig_var_MsgDirection_RECEIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MsgDirection_SEND",Swig_var_MsgDirection_SEND_get, Swig_var_MsgDirection_SEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateAction_DELETE",Swig_var_MDUpdateAction_DELETE_get, Swig_var_MDUpdateAction_DELETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateAction_NEW",Swig_var_MDUpdateAction_NEW_get, Swig_var_MDUpdateAction_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateAction_DELETE_THRU",Swig_var_MDUpdateAction_DELETE_THRU_get, Swig_var_MDUpdateAction_DELETE_THRU_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateAction_DELETE_FROM",Swig_var_MDUpdateAction_DELETE_FROM_get, Swig_var_MDUpdateAction_DELETE_FROM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateAction_OVERLAY",Swig_var_MDUpdateAction_OVERLAY_get, Swig_var_MDUpdateAction_OVERLAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDUpdateAction_CHANGE",Swig_var_MDUpdateAction_CHANGE_get, Swig_var_MDUpdateAction_CHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED",Swig_var_MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED_get, Swig_var_MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchStatus_COMPARED_MATCHED_OR_AFFIRMED",Swig_var_MatchStatus_COMPARED_MATCHED_OR_AFFIRMED_get, Swig_var_MatchStatus_COMPARED_MATCHED_OR_AFFIRMED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchStatus_ADVISORY_OR_ALERT",Swig_var_MatchStatus_ADVISORY_OR_ALERT_get, Swig_var_MatchStatus_ADVISORY_OR_ALERT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED",Swig_var_MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED_get, Swig_var_MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RateSource_REUTERS",Swig_var_RateSource_REUTERS_get, Swig_var_RateSource_REUTERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RateSource_OTHER",Swig_var_RateSource_OTHER_get, Swig_var_RateSource_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RateSource_BLOOMBERG",Swig_var_RateSource_BLOOMBERG_get, Swig_var_RateSource_BLOOMBERG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RateSource_TELERATE",Swig_var_RateSource_TELERATE_get, Swig_var_RateSource_TELERATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocPositionEffect_CLOSE",Swig_var_AllocPositionEffect_CLOSE_get, Swig_var_AllocPositionEffect_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocPositionEffect_FIFO",Swig_var_AllocPositionEffect_FIFO_get, Swig_var_AllocPositionEffect_FIFO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocPositionEffect_OPEN",Swig_var_AllocPositionEffect_OPEN_get, Swig_var_AllocPositionEffect_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocPositionEffect_ROLLED",Swig_var_AllocPositionEffect_ROLLED_get, Swig_var_AllocPositionEffect_ROLLED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER",Swig_var_PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER_get, Swig_var_PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_PROPRIETARY",Swig_var_PartyIDSource_PROPRIETARY_get, Swig_var_PartyIDSource_PROPRIETARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER",Swig_var_PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER_get, Swig_var_PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER",Swig_var_PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_get, Swig_var_PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER",Swig_var_PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER_get, Swig_var_PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER",Swig_var_PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER_get, Swig_var_PartyIDSource_US_EMPLOYER_IDENTIFICATION_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_TAIWANESE_TRADING_ACCOUNT",Swig_var_PartyIDSource_TAIWANESE_TRADING_ACCOUNT_get, Swig_var_PartyIDSource_TAIWANESE_TRADING_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_TAIWANESE_TRADING_ACCT",Swig_var_PartyIDSource_TAIWANESE_TRADING_ACCT_get, Swig_var_PartyIDSource_TAIWANESE_TRADING_ACCT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY",Swig_var_PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY_get, Swig_var_PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_US_SOCIAL_SECURITY_NUMBER",Swig_var_PartyIDSource_US_SOCIAL_SECURITY_NUMBER_get, Swig_var_PartyIDSource_US_SOCIAL_SECURITY_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER",Swig_var_PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER_get, Swig_var_PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE",Swig_var_PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE_get, Swig_var_PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_DIRECTED_BROKER_THREE_CHARACTER_ACRONYM_AS_DEFINED_IN_ISITC_ETC_BEST_PRACTICE_GUIDELINES_DOCUMENT",Swig_var_PartyIDSource_DIRECTED_BROKER_THREE_CHARACTER_ACRONYM_AS_DEFINED_IN_ISITC_ETC_BEST_PRACTICE_GUIDELINES_DOCUMENT_get, Swig_var_PartyIDSource_DIRECTED_BROKER_THREE_CHARACTER_ACRONYM_AS_DEFINED_IN_ISITC_ETC_BEST_PRACTICE_GUIDELINES_DOCUMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII",Swig_var_PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_get, Swig_var_PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_SETTLEMENT_ENTITY_LOCATION",Swig_var_PartyIDSource_SETTLEMENT_ENTITY_LOCATION_get, Swig_var_PartyIDSource_SETTLEMENT_ENTITY_LOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_PROPRIETARY_CUSTOM_CODE",Swig_var_PartyIDSource_PROPRIETARY_CUSTOM_CODE_get, Swig_var_PartyIDSource_PROPRIETARY_CUSTOM_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_BIC",Swig_var_PartyIDSource_BIC_get, Swig_var_PartyIDSource_BIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_CHINESE_INVESTOR_ID",Swig_var_PartyIDSource_CHINESE_INVESTOR_ID_get, Swig_var_PartyIDSource_CHINESE_INVESTOR_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_MIC",Swig_var_PartyIDSource_MIC_get, Swig_var_PartyIDSource_MIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_KOREAN_INVESTOR_ID",Swig_var_PartyIDSource_KOREAN_INVESTOR_ID_get, Swig_var_PartyIDSource_KOREAN_INVESTOR_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_ISO_COUNTRY_CODE",Swig_var_PartyIDSource_ISO_COUNTRY_CODE_get, Swig_var_PartyIDSource_ISO_COUNTRY_CODE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID",Swig_var_PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID_get, Swig_var_PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PartyIDSource_CHINESE_B_SHARE",Swig_var_PartyIDSource_CHINESE_B_SHARE_get, Swig_var_PartyIDSource_CHINESE_B_SHARE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExchangeForPhysical_NO",Swig_var_ExchangeForPhysical_NO_get, Swig_var_ExchangeForPhysical_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExchangeForPhysical_YES",Swig_var_ExchangeForPhysical_YES_get, Swig_var_ExchangeForPhysical_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS",Swig_var_SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS_get, Swig_var_SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_CHANGE_OF_TRADING_SESSION",Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SESSION_get, Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS",Swig_var_SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS_get, Swig_var_SecurityTradingEvent_CHANGE_OF_SECURITY_STATUS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION",Swig_var_SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION_get, Swig_var_SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_CHANGE_OF_BOOK_TYPE",Swig_var_SecurityTradingEvent_CHANGE_OF_BOOK_TYPE_get, Swig_var_SecurityTradingEvent_CHANGE_OF_BOOK_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION",Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION_get, Swig_var_SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH",Swig_var_SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH_get, Swig_var_SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_TRADING_RESUMES",Swig_var_SecurityTradingEvent_TRADING_RESUMES_get, Swig_var_SecurityTradingEvent_TRADING_RESUMES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED",Swig_var_SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED_get, Swig_var_SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAction_ADD",Swig_var_CollAction_ADD_get, Swig_var_CollAction_ADD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAction_REMOVE",Swig_var_CollAction_REMOVE_get, Swig_var_CollAction_REMOVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CollAction_RETAIN",Swig_var_CollAction_RETAIN_get, Swig_var_CollAction_RETAIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PossDupFlag_NO",Swig_var_PossDupFlag_NO_get, Swig_var_PossDupFlag_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PossDupFlag_YES",Swig_var_PossDupFlag_YES_get, Swig_var_PossDupFlag_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_ALL_DONE",Swig_var_ListStatusType_ALL_DONE_get, Swig_var_ListStatusType_ALL_DONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_TIMED",Swig_var_ListStatusType_TIMED_get, Swig_var_ListStatusType_TIMED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_EXECSTARTED",Swig_var_ListStatusType_EXECSTARTED_get, Swig_var_ListStatusType_EXECSTARTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_RESPONSE",Swig_var_ListStatusType_RESPONSE_get, Swig_var_ListStatusType_RESPONSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_ALLDONE",Swig_var_ListStatusType_ALLDONE_get, Swig_var_ListStatusType_ALLDONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_ALERT",Swig_var_ListStatusType_ALERT_get, Swig_var_ListStatusType_ALERT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_ACK",Swig_var_ListStatusType_ACK_get, Swig_var_ListStatusType_ACK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ListStatusType_EXEC_STARTED",Swig_var_ListStatusType_EXEC_STARTED_get, Swig_var_ListStatusType_EXEC_STARTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GapFillFlag_NO",Swig_var_GapFillFlag_NO_get, Swig_var_GapFillFlag_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"GapFillFlag_YES",Swig_var_GapFillFlag_YES_get, Swig_var_GapFillFlag_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING",Swig_var_TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING_get, Swig_var_TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeHandlingInstr_TWO_PARTY_REPORT",Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_get, Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING",Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING_get, Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeHandlingInstr_TRADE_CONFIRMATION",Swig_var_TradeHandlingInstr_TRADE_CONFIRMATION_get, Swig_var_TradeHandlingInstr_TRADE_CONFIRMATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH",Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH_get, Swig_var_TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM",Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM_get, Swig_var_TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesMethod_ELECTRONIC",Swig_var_TradSesMethod_ELECTRONIC_get, Swig_var_TradSesMethod_ELECTRONIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesMethod_TWO_PARTY",Swig_var_TradSesMethod_TWO_PARTY_get, Swig_var_TradSesMethod_TWO_PARTY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradSesMethod_OPEN_OUTCRY",Swig_var_TradSesMethod_OPEN_OUTCRY_get, Swig_var_TradSesMethod_OPEN_OUTCRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeType_AGENCY",Swig_var_TradeType_AGENCY_get, Swig_var_TradeType_AGENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeType_VWAP_GUARANTEE",Swig_var_TradeType_VWAP_GUARANTEE_get, Swig_var_TradeType_VWAP_GUARANTEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeType_RISK_TRADE",Swig_var_TradeType_RISK_TRADE_get, Swig_var_TradeType_RISK_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TradeType_GUARANTEED_CLOSE",Swig_var_TradeType_GUARANTEED_CLOSE_get, Swig_var_TradeType_GUARANTEED_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventCondition_AND",Swig_var_ComplexEventCondition_AND_get, Swig_var_ComplexEventCondition_AND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventCondition_OR",Swig_var_ComplexEventCondition_OR_get, Swig_var_ComplexEventCondition_OR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_SONIA",Swig_var_BenchmarkCurveName_SONIA_get, Swig_var_BenchmarkCurveName_SONIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_MUNIAAA",Swig_var_BenchmarkCurveName_MUNIAAA_get, Swig_var_BenchmarkCurveName_MUNIAAA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_LIBID",Swig_var_BenchmarkCurveName_LIBID_get, Swig_var_BenchmarkCurveName_LIBID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_PFANDBRIEFE",Swig_var_BenchmarkCurveName_PFANDBRIEFE_get, Swig_var_BenchmarkCurveName_PFANDBRIEFE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_EUREPO",Swig_var_BenchmarkCurveName_EUREPO_get, Swig_var_BenchmarkCurveName_EUREPO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_FUTURESWAP",Swig_var_BenchmarkCurveName_FUTURESWAP_get, Swig_var_BenchmarkCurveName_FUTURESWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_TREASURY",Swig_var_BenchmarkCurveName_TREASURY_get, Swig_var_BenchmarkCurveName_TREASURY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_OTHER",Swig_var_BenchmarkCurveName_OTHER_get, Swig_var_BenchmarkCurveName_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_EURIBOR",Swig_var_BenchmarkCurveName_EURIBOR_get, Swig_var_BenchmarkCurveName_EURIBOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_EONIA",Swig_var_BenchmarkCurveName_EONIA_get, Swig_var_BenchmarkCurveName_EONIA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_LIBOR",Swig_var_BenchmarkCurveName_LIBOR_get, Swig_var_BenchmarkCurveName_LIBOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BenchmarkCurveName_SWAP",Swig_var_BenchmarkCurveName_SWAP_get, Swig_var_BenchmarkCurveName_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CashMargin_MARGIN_CLOSE",Swig_var_CashMargin_MARGIN_CLOSE_get, Swig_var_CashMargin_MARGIN_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CashMargin_MARGIN_OPEN",Swig_var_CashMargin_MARGIN_OPEN_get, Swig_var_CashMargin_MARGIN_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CashMargin_CASH",Swig_var_CashMargin_CASH_get, Swig_var_CashMargin_CASH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligTransType_REPLACE",Swig_var_SettlObligTransType_REPLACE_get, Swig_var_SettlObligTransType_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligTransType_NEW",Swig_var_SettlObligTransType_NEW_get, Swig_var_SettlObligTransType_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligTransType_RESTATE",Swig_var_SettlObligTransType_RESTATE_get, Swig_var_SettlObligTransType_RESTATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlObligTransType_CANCEL",Swig_var_SettlObligTransType_CANCEL_get, Swig_var_SettlObligTransType_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_PEGGED",Swig_var_DeskOrderHandlingInst_PEGGED_get, Swig_var_DeskOrderHandlingInst_PEGGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_MARKET_ON_OPEN",Swig_var_DeskOrderHandlingInst_MARKET_ON_OPEN_get, Swig_var_DeskOrderHandlingInst_MARKET_ON_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_SCALE",Swig_var_DeskOrderHandlingInst_SCALE_get, Swig_var_DeskOrderHandlingInst_SCALE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_FILL_OR_KILL",Swig_var_DeskOrderHandlingInst_FILL_OR_KILL_get, Swig_var_DeskOrderHandlingInst_FILL_OR_KILL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_ALL_OR_NONE",Swig_var_DeskOrderHandlingInst_ALL_OR_NONE_get, Swig_var_DeskOrderHandlingInst_ALL_OR_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_NOT_HELD",Swig_var_DeskOrderHandlingInst_NOT_HELD_get, Swig_var_DeskOrderHandlingInst_NOT_HELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_DIRECTED_ORDER",Swig_var_DeskOrderHandlingInst_DIRECTED_ORDER_get, Swig_var_DeskOrderHandlingInst_DIRECTED_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_STOP_STOCK_TRANSACTION",Swig_var_DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_get, Swig_var_DeskOrderHandlingInst_STOP_STOCK_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_OVER_THE_DAY",Swig_var_DeskOrderHandlingInst_OVER_THE_DAY_get, Swig_var_DeskOrderHandlingInst_OVER_THE_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_ADD_ON_ORDER",Swig_var_DeskOrderHandlingInst_ADD_ON_ORDER_get, Swig_var_DeskOrderHandlingInst_ADD_ON_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_MARKET_AT_CLOSE",Swig_var_DeskOrderHandlingInst_MARKET_AT_CLOSE_get, Swig_var_DeskOrderHandlingInst_MARKET_AT_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_LIMIT_ON_OPEN",Swig_var_DeskOrderHandlingInst_LIMIT_ON_OPEN_get, Swig_var_DeskOrderHandlingInst_LIMIT_ON_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_CASH_NOT_HELD",Swig_var_DeskOrderHandlingInst_CASH_NOT_HELD_get, Swig_var_DeskOrderHandlingInst_CASH_NOT_HELD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_MARKET_ON_CLOSE",Swig_var_DeskOrderHandlingInst_MARKET_ON_CLOSE_get, Swig_var_DeskOrderHandlingInst_MARKET_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_TIME_ORDER",Swig_var_DeskOrderHandlingInst_TIME_ORDER_get, Swig_var_DeskOrderHandlingInst_TIME_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_LIMIT_ON_CLOSE",Swig_var_DeskOrderHandlingInst_LIMIT_ON_CLOSE_get, Swig_var_DeskOrderHandlingInst_LIMIT_ON_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL",Swig_var_DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_get, Swig_var_DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_TRAILING_STOP",Swig_var_DeskOrderHandlingInst_TRAILING_STOP_get, Swig_var_DeskOrderHandlingInst_TRAILING_STOP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_WORK",Swig_var_DeskOrderHandlingInst_WORK_get, Swig_var_DeskOrderHandlingInst_WORK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_RESERVE_SIZE_ORDER",Swig_var_DeskOrderHandlingInst_RESERVE_SIZE_ORDER_get, Swig_var_DeskOrderHandlingInst_RESERVE_SIZE_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_MINIMUM_QUANTITY",Swig_var_DeskOrderHandlingInst_MINIMUM_QUANTITY_get, Swig_var_DeskOrderHandlingInst_MINIMUM_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_MARKET_AT_OPEN",Swig_var_DeskOrderHandlingInst_MARKET_AT_OPEN_get, Swig_var_DeskOrderHandlingInst_MARKET_AT_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_IMBALANCE_ONLY",Swig_var_DeskOrderHandlingInst_IMBALANCE_ONLY_get, Swig_var_DeskOrderHandlingInst_IMBALANCE_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION",Swig_var_DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_get, Swig_var_DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION",Swig_var_PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION_get, Swig_var_PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_DO_NOT_EXERCISE",Swig_var_PosTransType_DO_NOT_EXERCISE_get, Swig_var_PosTransType_DO_NOT_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_LARGE_TRADER_SUBMISSION",Swig_var_PosTransType_LARGE_TRADER_SUBMISSION_get, Swig_var_PosTransType_LARGE_TRADER_SUBMISSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_EXERCISE",Swig_var_PosTransType_EXERCISE_get, Swig_var_PosTransType_EXERCISE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_PLEDGE",Swig_var_PosTransType_PLEDGE_get, Swig_var_PosTransType_PLEDGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosTransType_POSITION_ADJUSTMENT",Swig_var_PosTransType_POSITION_ADJUSTMENT_get, Swig_var_PosTransType_POSITION_ADJUSTMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Seniority_SUBORDINATED",Swig_var_Seniority_SUBORDINATED_get, Swig_var_Seniority_SUBORDINATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Seniority_SENIOR_SECURED",Swig_var_Seniority_SENIOR_SECURED_get, Swig_var_Seniority_SENIOR_SECURED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Seniority_SENIOR",Swig_var_Seniority_SENIOR_get, Swig_var_Seniority_SENIOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlCurrFxRateCalc_DIVIDE",Swig_var_SettlCurrFxRateCalc_DIVIDE_get, Swig_var_SettlCurrFxRateCalc_DIVIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlCurrFxRateCalc_MULTIPLY",Swig_var_SettlCurrFxRateCalc_MULTIPLY_get, Swig_var_SettlCurrFxRateCalc_MULTIPLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintStatus_COMPLETED",Swig_var_PosMaintStatus_COMPLETED_get, Swig_var_PosMaintStatus_COMPLETED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintStatus_ACCEPTED_WITH_WARNINGS",Swig_var_PosMaintStatus_ACCEPTED_WITH_WARNINGS_get, Swig_var_PosMaintStatus_ACCEPTED_WITH_WARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintStatus_REJECTED",Swig_var_PosMaintStatus_REJECTED_get, Swig_var_PosMaintStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintStatus_ACCEPTED",Swig_var_PosMaintStatus_ACCEPTED_get, Swig_var_PosMaintStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintStatus_COMPLETED_WITH_WARNINGS",Swig_var_PosMaintStatus_COMPLETED_WITH_WARNINGS_get, Swig_var_PosMaintStatus_COMPLETED_WITH_WARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_6_MO_LIBOR",Swig_var_Benchmark_6_MO_LIBOR_get, Swig_var_Benchmark_6_MO_LIBOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_OLD_5",Swig_var_Benchmark_OLD_5_get, Swig_var_Benchmark_OLD_5_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_OLD_30",Swig_var_Benchmark_OLD_30_get, Swig_var_Benchmark_OLD_30_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_3_MO_LIBOR",Swig_var_Benchmark_3_MO_LIBOR_get, Swig_var_Benchmark_3_MO_LIBOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_OLD_10",Swig_var_Benchmark_OLD_10_get, Swig_var_Benchmark_OLD_10_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_CURVE",Swig_var_Benchmark_CURVE_get, Swig_var_Benchmark_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_30_YR",Swig_var_Benchmark_30_YR_get, Swig_var_Benchmark_30_YR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_10_YR",Swig_var_Benchmark_10_YR_get, Swig_var_Benchmark_10_YR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Benchmark_5_YR",Swig_var_Benchmark_5_YR_get, Swig_var_Benchmark_5_YR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MaturityMonthYearFormat_YEARMONTHWEEK",Swig_var_MaturityMonthYearFormat_YEARMONTHWEEK_get, Swig_var_MaturityMonthYearFormat_YEARMONTHWEEK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MaturityMonthYearFormat_YEARMONTHDAY",Swig_var_MaturityMonthYearFormat_YEARMONTHDAY_get, Swig_var_MaturityMonthYearFormat_YEARMONTHDAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MaturityMonthYearFormat_YEARMONTH_ONLY",Swig_var_MaturityMonthYearFormat_YEARMONTH_ONLY_get, Swig_var_MaturityMonthYearFormat_YEARMONTH_ONLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LegalConfirm_NO",Swig_var_LegalConfirm_NO_get, Swig_var_LegalConfirm_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LegalConfirm_YES",Swig_var_LegalConfirm_YES_get, Swig_var_LegalConfirm_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReportType_REPORTS_THAT_THE_LAST_MESSAGE_HAS_BEEN_SENT_FOR_THE_APPLIDS_REFER_TO_REFAPPLLASTSEQNUM",Swig_var_ApplReportType_REPORTS_THAT_THE_LAST_MESSAGE_HAS_BEEN_SENT_FOR_THE_APPLIDS_REFER_TO_REFAPPLLASTSEQNUM_get, Swig_var_ApplReportType_REPORTS_THAT_THE_LAST_MESSAGE_HAS_BEEN_SENT_FOR_THE_APPLIDS_REFER_TO_REFAPPLLASTSEQNUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED",Swig_var_ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED_get, Swig_var_ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM",Swig_var_ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM_get, Swig_var_ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID",Swig_var_ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID_get, Swig_var_ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ReportToExch_NO",Swig_var_ReportToExch_NO_get, Swig_var_ReportToExch_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ReportToExch_YES",Swig_var_ReportToExch_YES_get, Swig_var_ReportToExch_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_INCORRECT_ALLOCATED_QUANTITY",Swig_var_AllocRejCode_INCORRECT_ALLOCATED_QUANTITY_get, Swig_var_AllocRejCode_INCORRECT_ALLOCATED_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWN_ORDERID",Swig_var_AllocRejCode_UNKNOWN_ORDERID_get, Swig_var_AllocRejCode_UNKNOWN_ORDERID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_INCORRECT_AVERAGEG_PRICE",Swig_var_AllocRejCode_INCORRECT_AVERAGEG_PRICE_get, Swig_var_AllocRejCode_INCORRECT_AVERAGEG_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_WAREHOUSE_REQUEST_REJECTED",Swig_var_AllocRejCode_WAREHOUSE_REQUEST_REJECTED_get, Swig_var_AllocRejCode_WAREHOUSE_REQUEST_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_OTHER_99",Swig_var_AllocRejCode_OTHER_99_get, Swig_var_AllocRejCode_OTHER_99_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWN_LISTID",Swig_var_AllocRejCode_UNKNOWN_LISTID_get, Swig_var_AllocRejCode_UNKNOWN_LISTID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_INCORRECT_QUANTITY",Swig_var_AllocRejCode_INCORRECT_QUANTITY_get, Swig_var_AllocRejCode_INCORRECT_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_INCORRECT_AVERAGE_PRICE",Swig_var_AllocRejCode_INCORRECT_AVERAGE_PRICE_get, Swig_var_AllocRejCode_INCORRECT_AVERAGE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWN_ACCOUNT",Swig_var_AllocRejCode_UNKNOWN_ACCOUNT_get, Swig_var_AllocRejCode_UNKNOWN_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWN_OR_STALE_EXECID",Swig_var_AllocRejCode_UNKNOWN_OR_STALE_EXECID_get, Swig_var_AllocRejCode_UNKNOWN_OR_STALE_EXECID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_MISMATCHED_DATA_VALUE",Swig_var_AllocRejCode_MISMATCHED_DATA_VALUE_get, Swig_var_AllocRejCode_MISMATCHED_DATA_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_OTHER",Swig_var_AllocRejCode_OTHER_get, Swig_var_AllocRejCode_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_OTHER_7",Swig_var_AllocRejCode_OTHER_7_get, Swig_var_AllocRejCode_OTHER_7_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWN_CLORDID",Swig_var_AllocRejCode_UNKNOWN_CLORDID_get, Swig_var_AllocRejCode_UNKNOWN_CLORDID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_MISMATCHED_DATA",Swig_var_AllocRejCode_MISMATCHED_DATA_get, Swig_var_AllocRejCode_MISMATCHED_DATA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_CALCULATION_DIFFERENCE",Swig_var_AllocRejCode_CALCULATION_DIFFERENCE_get, Swig_var_AllocRejCode_CALCULATION_DIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_COMMISSION_DIFFERENCE",Swig_var_AllocRejCode_COMMISSION_DIFFERENCE_get, Swig_var_AllocRejCode_COMMISSION_DIFFERENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC",Swig_var_AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC_get, Swig_var_AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrdIDReason_GTC_FROM_PREVIOUS_DAY",Swig_var_RefOrdIDReason_GTC_FROM_PREVIOUS_DAY_get, Swig_var_RefOrdIDReason_GTC_FROM_PREVIOUS_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrdIDReason_PARTIAL_FILL_REMAINING",Swig_var_RefOrdIDReason_PARTIAL_FILL_REMAINING_get, Swig_var_RefOrdIDReason_PARTIAL_FILL_REMAINING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrdIDReason_ORDER_CHANGED",Swig_var_RefOrdIDReason_ORDER_CHANGED_get, Swig_var_RefOrdIDReason_ORDER_CHANGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_SECONDARYORDERID",Swig_var_RefOrderIDSource_SECONDARYORDERID_get, Swig_var_RefOrderIDSource_SECONDARYORDERID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_ORDERID",Swig_var_RefOrderIDSource_ORDERID_get, Swig_var_RefOrderIDSource_ORDERID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_MDENTRYID",Swig_var_RefOrderIDSource_MDENTRYID_get, Swig_var_RefOrderIDSource_MDENTRYID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_ORIGINAL_ORDER_ID",Swig_var_RefOrderIDSource_ORIGINAL_ORDER_ID_get, Swig_var_RefOrderIDSource_ORIGINAL_ORDER_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_MENTRYID",Swig_var_RefOrderIDSource_MENTRYID_get, Swig_var_RefOrderIDSource_MENTRYID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_QUOTEENTRYID",Swig_var_RefOrderIDSource_QUOTEENTRYID_get, Swig_var_RefOrderIDSource_QUOTEENTRYID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_QUOTENTRYID",Swig_var_RefOrderIDSource_QUOTENTRYID_get, Swig_var_RefOrderIDSource_QUOTENTRYID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_ORDEID",Swig_var_RefOrderIDSource_ORDEID_get, Swig_var_RefOrderIDSource_ORDEID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RefOrderIDSource_SECONDARYORDEID",Swig_var_RefOrderIDSource_SECONDARYORDEID_get, Swig_var_RefOrderIDSource_SECONDARYORDEID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastCapacity_CROSS_AS_PRINCIPAL",Swig_var_LastCapacity_CROSS_AS_PRINCIPAL_get, Swig_var_LastCapacity_CROSS_AS_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastCapacity_PRINCIPAL",Swig_var_LastCapacity_PRINCIPAL_get, Swig_var_LastCapacity_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastCapacity_CROSS_AS_AGENT",Swig_var_LastCapacity_CROSS_AS_AGENT_get, Swig_var_LastCapacity_CROSS_AS_AGENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LastCapacity_AGENT",Swig_var_LastCapacity_AGENT_get, Swig_var_LastCapacity_AGENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_INSTRUMENT_STRIKE_PRICE",Swig_var_InstrAttribType_INSTRUMENT_STRIKE_PRICE_get, Swig_var_InstrAttribType_INSTRUMENT_STRIKE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_IN_DEFAULT",Swig_var_InstrAttribType_IN_DEFAULT_get, Swig_var_InstrAttribType_IN_DEFAULT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_PRE_REFUNDED",Swig_var_InstrAttribType_PRE_REFUNDED_get, Swig_var_InstrAttribType_PRE_REFUNDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX",Swig_var_InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX_get, Swig_var_InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ORIGINAL_ISSUE_DISCOUNT",Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_get, Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_UNRATED",Swig_var_InstrAttribType_UNRATED_get, Swig_var_InstrAttribType_UNRATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_WHEN_AND_IF_ISSUED",Swig_var_InstrAttribType_WHEN_AND_IF_ISSUED_get, Swig_var_InstrAttribType_WHEN_AND_IF_ISSUED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED",Swig_var_InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED_get, Swig_var_InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_CALLABLE_SUPPLY_REDEMPTION_DATE_IN_THE_INSTRATTRIBVALUE",Swig_var_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_CALLABLE_SUPPLY_REDEMPTION_DATE_IN_THE_INSTRATTRIBVALUE_get, Swig_var_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_CALLABLE_SUPPLY_REDEMPTION_DATE_IN_THE_INSTRATTRIBVALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_STEPPED_COUPON",Swig_var_InstrAttribType_STEPPED_COUPON_get, Swig_var_InstrAttribType_STEPPED_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_INSTRUMENT_DENOMINATOR",Swig_var_InstrAttribType_INSTRUMENT_DENOMINATOR_get, Swig_var_InstrAttribType_INSTRUMENT_DENOMINATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ESCROWED_TO_REDEMPTION_DATE",Swig_var_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_get, Swig_var_InstrAttribType_ESCROWED_TO_REDEMPTION_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_TAXABLE",Swig_var_InstrAttribType_TAXABLE_get, Swig_var_InstrAttribType_TAXABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_INTEREST_BEARING",Swig_var_InstrAttribType_INTEREST_BEARING_get, Swig_var_InstrAttribType_INTEREST_BEARING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE",Swig_var_InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE_get, Swig_var_InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_PREREFUNDED",Swig_var_InstrAttribType_PREREFUNDED_get, Swig_var_InstrAttribType_PREREFUNDED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_CALLABLE_PUTTABLE",Swig_var_InstrAttribType_CALLABLE_PUTTABLE_get, Swig_var_InstrAttribType_CALLABLE_PUTTABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_COUPON_PERIOD",Swig_var_InstrAttribType_COUPON_PERIOD_get, Swig_var_InstrAttribType_COUPON_PERIOD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_INSTRUMENT_PRICE_PRECISION",Swig_var_InstrAttribType_INSTRUMENT_PRICE_PRECISION_get, Swig_var_InstrAttribType_INSTRUMENT_PRICE_PRECISION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_TRADEABLE_INDICATOR",Swig_var_InstrAttribType_TRADEABLE_INDICATOR_get, Swig_var_InstrAttribType_TRADEABLE_INDICATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE",Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE_get, Swig_var_InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_VARIABLE_RATE",Swig_var_InstrAttribType_VARIABLE_RATE_get, Swig_var_InstrAttribType_VARIABLE_RATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_FLAT",Swig_var_InstrAttribType_FLAT_get, Swig_var_InstrAttribType_FLAT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY",Swig_var_InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY_get, Swig_var_InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_INSTRUMENT_NUMERATOR",Swig_var_InstrAttribType_INSTRUMENT_NUMERATOR_get, Swig_var_InstrAttribType_INSTRUMENT_NUMERATOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE",Swig_var_InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE_get, Swig_var_InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_INDEXED",Swig_var_InstrAttribType_INDEXED_get, Swig_var_InstrAttribType_INDEXED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ESCROWED_TO_MATURITY",Swig_var_InstrAttribType_ESCROWED_TO_MATURITY_get, Swig_var_InstrAttribType_ESCROWED_TO_MATURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_LESS_FEE_FOR_PUT",Swig_var_InstrAttribType_LESS_FEE_FOR_PUT_get, Swig_var_InstrAttribType_LESS_FEE_FOR_PUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_ZERO_COUPON",Swig_var_InstrAttribType_ZERO_COUPON_get, Swig_var_InstrAttribType_ZERO_COUPON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY",Swig_var_InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY_get, Swig_var_InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"InstrAttribType_NO_PERIODIC_PAYMENTS",Swig_var_InstrAttribType_NO_PERIODIC_PAYMENTS_get, Swig_var_InstrAttribType_NO_PERIODIC_PAYMENTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_FINANCING",Swig_var_Product_FINANCING_get, Swig_var_Product_FINANCING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_COMMODITY",Swig_var_Product_COMMODITY_get, Swig_var_Product_COMMODITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_EQUITY",Swig_var_Product_EQUITY_get, Swig_var_Product_EQUITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_CORPORATE",Swig_var_Product_CORPORATE_get, Swig_var_Product_CORPORATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_AGENCY",Swig_var_Product_AGENCY_get, Swig_var_Product_AGENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_OTHER",Swig_var_Product_OTHER_get, Swig_var_Product_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_MONEYMARKET",Swig_var_Product_MONEYMARKET_get, Swig_var_Product_MONEYMARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_MORTGAGE",Swig_var_Product_MORTGAGE_get, Swig_var_Product_MORTGAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_CURRENCY",Swig_var_Product_CURRENCY_get, Swig_var_Product_CURRENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_INDEX",Swig_var_Product_INDEX_get, Swig_var_Product_INDEX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_MUNICIPAL",Swig_var_Product_MUNICIPAL_get, Swig_var_Product_MUNICIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_LOAN",Swig_var_Product_LOAN_get, Swig_var_Product_LOAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Product_GOVERNMENT",Swig_var_Product_GOVERNMENT_get, Swig_var_Product_GOVERNMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_FAST_MARKET",Swig_var_SecurityTradingStatus_FAST_MARKET_get, Swig_var_SecurityTradingStatus_FAST_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NO_OPEN_NO_RESUME",Swig_var_SecurityTradingStatus_NO_OPEN_NO_RESUME_get, Swig_var_SecurityTradingStatus_NO_OPEN_NO_RESUME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_TRADING_HALT",Swig_var_SecurityTradingStatus_TRADING_HALT_get, Swig_var_SecurityTradingStatus_TRADING_HALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING",Swig_var_SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING_get, Swig_var_SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NO_OPEN",Swig_var_SecurityTradingStatus_NO_OPEN_get, Swig_var_SecurityTradingStatus_NO_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_CROSS",Swig_var_SecurityTradingStatus_CROSS_get, Swig_var_SecurityTradingStatus_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_RESUME",Swig_var_SecurityTradingStatus_RESUME_get, Swig_var_SecurityTradingStatus_RESUME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_TRADE_DISSEMINATION_TIME",Swig_var_SecurityTradingStatus_TRADE_DISSEMINATION_TIME_get, Swig_var_SecurityTradingStatus_TRADE_DISSEMINATION_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE",Swig_var_SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE_get, Swig_var_SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_POST_CLOSE",Swig_var_SecurityTradingStatus_POST_CLOSE_get, Swig_var_SecurityTradingStatus_POST_CLOSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY",Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY_get, Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_MARKET_IMBALANCE_SELL",Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_SELL_get, Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_SELL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_OPENING_DELAY",Swig_var_SecurityTradingStatus_OPENING_DELAY_get, Swig_var_SecurityTradingStatus_OPENING_DELAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET",Swig_var_SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET_get, Swig_var_SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_ITS_PRE_OPENING",Swig_var_SecurityTradingStatus_ITS_PRE_OPENING_get, Swig_var_SecurityTradingStatus_ITS_PRE_OPENING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_PRE_CROSS",Swig_var_SecurityTradingStatus_PRE_CROSS_get, Swig_var_SecurityTradingStatus_PRE_CROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_PRE_OPEN",Swig_var_SecurityTradingStatus_PRE_OPEN_get, Swig_var_SecurityTradingStatus_PRE_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_MARKET_IMBALANCE_BUY",Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_BUY_get, Swig_var_SecurityTradingStatus_MARKET_IMBALANCE_BUY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_TRADING_RANGE_INDICATION",Swig_var_SecurityTradingStatus_TRADING_RANGE_INDICATION_get, Swig_var_SecurityTradingStatus_TRADING_RANGE_INDICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_READY_TO_TRADE",Swig_var_SecurityTradingStatus_READY_TO_TRADE_get, Swig_var_SecurityTradingStatus_READY_TO_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NEW_PRICE_INDICATION",Swig_var_SecurityTradingStatus_NEW_PRICE_INDICATION_get, Swig_var_SecurityTradingStatus_NEW_PRICE_INDICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_OPENING_ROTATION",Swig_var_SecurityTradingStatus_OPENING_ROTATION_get, Swig_var_SecurityTradingStatus_OPENING_ROTATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_PRICE_INDICATION",Swig_var_SecurityTradingStatus_PRICE_INDICATION_get, Swig_var_SecurityTradingStatus_PRICE_INDICATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_UNKNOWN_OR_INVALID",Swig_var_SecurityTradingStatus_UNKNOWN_OR_INVALID_get, Swig_var_SecurityTradingStatus_UNKNOWN_OR_INVALID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL",Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL_get, Swig_var_SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SecurityTradingStatus_NO_MARKET_IMBALANCE",Swig_var_SecurityTradingStatus_NO_MARKET_IMBALANCE_get, Swig_var_SecurityTradingStatus_NO_MARKET_IMBALANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER",Swig_var_Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER_get, Swig_var_Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPETING_MARKET_MAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SPECIALIST_TRADES",Swig_var_Rule80A_SPECIALIST_TRADES_get, Swig_var_Rule80A_SPECIALIST_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER",Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_get, Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG",Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG_get, Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHORT_EXEMPT_TRANSACTION_F",Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_F_get, Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_F_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_COMPETING_DEALER_TRADES_O",Swig_var_Rule80A_COMPETING_DEALER_TRADES_O_get, Swig_var_Rule80A_COMPETING_DEALER_TRADES_O_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER",Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_get, Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_INDIVIDUAL_CUSTOMER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHORT_EXEMPT_TRANSACTION_H",Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_H_get, Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_H_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PRINCIPAL",Swig_var_Rule80A_PRINCIPAL_get, Swig_var_Rule80A_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_COMPETING_DEALER_TRADES_R",Swig_var_Rule80A_COMPETING_DEALER_TRADES_R_get, Swig_var_Rule80A_COMPETING_DEALER_TRADES_R_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER",Swig_var_Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER_get, Swig_var_Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER",Swig_var_Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER_get, Swig_var_Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_NOT_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE",Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_NOT_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_get, Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_NOT_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_COMPETING_DEALER_TRADES_T",Swig_var_Rule80A_COMPETING_DEALER_TRADES_T_get, Swig_var_Rule80A_COMPETING_DEALER_TRADES_T_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER",Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER_get, Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER",Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER_get, Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_AGENCY",Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_AGENCY_get, Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_OTHER_AGENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER",Swig_var_Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER_get, Swig_var_Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_MEMBER_FIRM_ORG",Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_MEMBER_FIRM_ORG_get, Swig_var_Rule80A_PROGRAM_ORDER_NON_INDEX_ARB_FOR_MEMBER_FIRM_ORG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL",Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL_get, Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHORT_EXEMPT_TRANSACTION_B",Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_B_get, Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_B_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE",Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_get, Swig_var_Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_AGENCY_SINGLE_ORDER",Swig_var_Rule80A_AGENCY_SINGLE_ORDER_get, Swig_var_Rule80A_AGENCY_SINGLE_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER",Swig_var_Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER_get, Swig_var_Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES",Swig_var_Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES_get, Swig_var_Rule80A_REGISTERED_EQUITY_MARKET_MAKER_TRADES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY",Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY_get, Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_AGENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER",Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER_get, Swig_var_Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_MERGER_REORGANIZATION",Swig_var_CorporateAction_MERGER_REORGANIZATION_get, Swig_var_CorporateAction_MERGER_REORGANIZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_SYMBOL_CONVERSION",Swig_var_CorporateAction_SYMBOL_CONVERSION_get, Swig_var_CorporateAction_SYMBOL_CONVERSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_NEW",Swig_var_CorporateAction_NEW_get, Swig_var_CorporateAction_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_SUCCESSION_EVENT",Swig_var_CorporateAction_SUCCESSION_EVENT_get, Swig_var_CorporateAction_SUCCESSION_EVENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_STOCK_DIVIDEND",Swig_var_CorporateAction_STOCK_DIVIDEND_get, Swig_var_CorporateAction_STOCK_DIVIDEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_REVERSE_STOCK_SPLIT",Swig_var_CorporateAction_REVERSE_STOCK_SPLIT_get, Swig_var_CorporateAction_REVERSE_STOCK_SPLIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_POSITION_CONSOLIDATION",Swig_var_CorporateAction_POSITION_CONSOLIDATION_get, Swig_var_CorporateAction_POSITION_CONSOLIDATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_SPINOFF",Swig_var_CorporateAction_SPINOFF_get, Swig_var_CorporateAction_SPINOFF_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_EX_INTEREST",Swig_var_CorporateAction_EX_INTEREST_get, Swig_var_CorporateAction_EX_INTEREST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_LIQUIDATION_REORGANIZATION",Swig_var_CorporateAction_LIQUIDATION_REORGANIZATION_get, Swig_var_CorporateAction_LIQUIDATION_REORGANIZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_CASH_DIVIDEND",Swig_var_CorporateAction_CASH_DIVIDEND_get, Swig_var_CorporateAction_CASH_DIVIDEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_STANDARD_INTEGER_STOCK_SPLIT",Swig_var_CorporateAction_STANDARD_INTEGER_STOCK_SPLIT_get, Swig_var_CorporateAction_STANDARD_INTEGER_STOCK_SPLIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_RIGHTS_OFFERING",Swig_var_CorporateAction_RIGHTS_OFFERING_get, Swig_var_CorporateAction_RIGHTS_OFFERING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_SHAREHOLDER_MEETING",Swig_var_CorporateAction_SHAREHOLDER_MEETING_get, Swig_var_CorporateAction_SHAREHOLDER_MEETING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_WARRANT",Swig_var_CorporateAction_WARRANT_get, Swig_var_CorporateAction_WARRANT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_EX_RIGHTS",Swig_var_CorporateAction_EX_RIGHTS_get, Swig_var_CorporateAction_EX_RIGHTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_EX_DISTRIBUTION",Swig_var_CorporateAction_EX_DISTRIBUTION_get, Swig_var_CorporateAction_EX_DISTRIBUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_EX_DIVIDEND",Swig_var_CorporateAction_EX_DIVIDEND_get, Swig_var_CorporateAction_EX_DIVIDEND_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_TENDER_OFFER",Swig_var_CorporateAction_TENDER_OFFER_get, Swig_var_CorporateAction_TENDER_OFFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_SPECIAL_ACTION",Swig_var_CorporateAction_SPECIAL_ACTION_get, Swig_var_CorporateAction_SPECIAL_ACTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_NON_INTEGER_STOCK_SPLIT",Swig_var_CorporateAction_NON_INTEGER_STOCK_SPLIT_get, Swig_var_CorporateAction_NON_INTEGER_STOCK_SPLIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_CUSIP",Swig_var_CorporateAction_CUSIP_get, Swig_var_CorporateAction_CUSIP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CorporateAction_LEAP_ROLLOVER",Swig_var_CorporateAction_LEAP_ROLLOVER_get, Swig_var_CorporateAction_LEAP_ROLLOVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TerminationType_TERM",Swig_var_TerminationType_TERM_get, Swig_var_TerminationType_TERM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TerminationType_FLEXIBLE",Swig_var_TerminationType_FLEXIBLE_get, Swig_var_TerminationType_FLEXIBLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TerminationType_OPEN",Swig_var_TerminationType_OPEN_get, Swig_var_TerminationType_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TerminationType_OVERNIGHT",Swig_var_TerminationType_OVERNIGHT_get, Swig_var_TerminationType_OVERNIGHT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintAction_NEW",Swig_var_PosMaintAction_NEW_get, Swig_var_PosMaintAction_NEW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintAction_REPLACE",Swig_var_PosMaintAction_REPLACE_get, Swig_var_PosMaintAction_REPLACE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintAction_REVERSE",Swig_var_PosMaintAction_REVERSE_get, Swig_var_PosMaintAction_REVERSE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintAction_CANCEL_USED_TO_REMOVE_THE_OVERALL_TRANSACTION_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_REFERENCE_ID",Swig_var_PosMaintAction_CANCEL_USED_TO_REMOVE_THE_OVERALL_TRANSACTION_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_REFERENCE_ID_get, Swig_var_PosMaintAction_CANCEL_USED_TO_REMOVE_THE_OVERALL_TRANSACTION_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_REFERENCE_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintAction_REPLACE_USED_TO_OVERRIDE_THE_OVERALL_TRANSACTION_QUANTITY_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_THE_REFERENCE_ID",Swig_var_PosMaintAction_REPLACE_USED_TO_OVERRIDE_THE_OVERALL_TRANSACTION_QUANTITY_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_THE_REFERENCE_ID_get, Swig_var_PosMaintAction_REPLACE_USED_TO_OVERRIDE_THE_OVERALL_TRANSACTION_QUANTITY_OR_SPECIFIC_ADD_MESSAGES_BASED_ON_THE_REFERENCE_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintAction_CANCEL",Swig_var_PosMaintAction_CANCEL_get, Swig_var_PosMaintAction_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosMaintAction_NEW_USED_TO_INCREMENT_THE_OVERALL_TRANSACTION_QUANTITY",Swig_var_PosMaintAction_NEW_USED_TO_INCREMENT_THE_OVERALL_TRANSACTION_QUANTITY_get, Swig_var_PosMaintAction_NEW_USED_TO_INCREMENT_THE_OVERALL_TRANSACTION_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceTimeType_SPECIFIED_DATE_TIME",Swig_var_ComplexEventPriceTimeType_SPECIFIED_DATE_TIME_get, Swig_var_ComplexEventPriceTimeType_SPECIFIED_DATE_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceTimeType_EXPIRATION",Swig_var_ComplexEventPriceTimeType_EXPIRATION_get, Swig_var_ComplexEventPriceTimeType_EXPIRATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ComplexEventPriceTimeType_IMMEDIATE",Swig_var_ComplexEventPriceTimeType_IMMEDIATE_get, Swig_var_ComplexEventPriceTimeType_IMMEDIATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingFXRateCalc_DIVIDE",Swig_var_UnderlyingFXRateCalc_DIVIDE_get, Swig_var_UnderlyingFXRateCalc_DIVIDE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"UnderlyingFXRateCalc_MULTIPLY",Swig_var_UnderlyingFXRateCalc_MULTIPLY_get, Swig_var_UnderlyingFXRateCalc_MULTIPLY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OddLot_NO",Swig_var_OddLot_NO_get, Swig_var_OddLot_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OddLot_YES",Swig_var_OddLot_YES_get, Swig_var_OddLot_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE",Swig_var_BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE_get, Swig_var_BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_AND_BOOK_ONE_TRADE_PER_ORDER",Swig_var_BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_AND_BOOK_ONE_TRADE_PER_ORDER_get, Swig_var_BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_AND_BOOK_ONE_TRADE_PER_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT",Swig_var_BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT_get, Swig_var_BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_REJECTED_BY_INTERMEDIARY",Swig_var_AllocStatus_REJECTED_BY_INTERMEDIARY_get, Swig_var_AllocStatus_REJECTED_BY_INTERMEDIARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_BLOCK_LEVEL_REJECT",Swig_var_AllocStatus_BLOCK_LEVEL_REJECT_get, Swig_var_AllocStatus_BLOCK_LEVEL_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_ACCOUNT_LEVEL_REJECT",Swig_var_AllocStatus_ACCOUNT_LEVEL_REJECT_get, Swig_var_AllocStatus_ACCOUNT_LEVEL_REJECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_INCOMPLETE",Swig_var_AllocStatus_INCOMPLETE_get, Swig_var_AllocStatus_INCOMPLETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_ALLOCATION_PENDING",Swig_var_AllocStatus_ALLOCATION_PENDING_get, Swig_var_AllocStatus_ALLOCATION_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_REVERSED",Swig_var_AllocStatus_REVERSED_get, Swig_var_AllocStatus_REVERSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_RECEIVED",Swig_var_AllocStatus_RECEIVED_get, Swig_var_AllocStatus_RECEIVED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_PARTIAL_ACCEPT",Swig_var_AllocStatus_PARTIAL_ACCEPT_get, Swig_var_AllocStatus_PARTIAL_ACCEPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_REJECTED",Swig_var_AllocStatus_REJECTED_get, Swig_var_AllocStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AllocStatus_ACCEPTED",Swig_var_AllocStatus_ACCEPTED_get, Swig_var_AllocStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IncTaxInd_NET",Swig_var_IncTaxInd_NET_get, Swig_var_IncTaxInd_NET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IncTaxInd_GROSS",Swig_var_IncTaxInd_GROSS_get, Swig_var_IncTaxInd_GROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqStatus_COMPLETED",Swig_var_PosReqStatus_COMPLETED_get, Swig_var_PosReqStatus_COMPLETED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqStatus_REJECTED",Swig_var_PosReqStatus_REJECTED_get, Swig_var_PosReqStatus_REJECTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PosReqStatus_COMPLETED_WITH_WARNINGS",Swig_var_PosReqStatus_COMPLETED_WITH_WARNINGS_get, Swig_var_PosReqStatus_COMPLETED_WITH_WARNINGS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriorityIndicator_PRIORITY_UNCHANGED",Swig_var_PriorityIndicator_PRIORITY_UNCHANGED_get, Swig_var_PriorityIndicator_PRIORITY_UNCHANGED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE",Swig_var_PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE_get, Swig_var_PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT",Swig_var_MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT_get, Swig_var_MoneyLaunderingStatus_EXEMPT_BELOW_THE_LIMIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION",Swig_var_MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION_get, Swig_var_MoneyLaunderingStatus_EXEMPT_CLIENT_MONEY_TYPE_EXEMPTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION",Swig_var_MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION_get, Swig_var_MoneyLaunderingStatus_EXEMPT_AUTHORISED_CREDIT_OR_FINANCIAL_INSTITUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_NOT_CHECKED",Swig_var_MoneyLaunderingStatus_NOT_CHECKED_get, Swig_var_MoneyLaunderingStatus_NOT_CHECKED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_PASSED",Swig_var_MoneyLaunderingStatus_PASSED_get, Swig_var_MoneyLaunderingStatus_PASSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXEMPT_1",Swig_var_MoneyLaunderingStatus_EXEMPT_1_get, Swig_var_MoneyLaunderingStatus_EXEMPT_1_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXEMPT_2",Swig_var_MoneyLaunderingStatus_EXEMPT_2_get, Swig_var_MoneyLaunderingStatus_EXEMPT_2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MoneyLaunderingStatus_EXEMPT_3",Swig_var_MoneyLaunderingStatus_EXEMPT_3_get, Swig_var_MoneyLaunderingStatus_EXEMPT_3_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE",Swig_var_LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE_get, Swig_var_LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LotType_ROUND_LOT",Swig_var_LotType_ROUND_LOT_get, Swig_var_LotType_ROUND_LOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LotType_ODD_LOT",Swig_var_LotType_ODD_LOT_get, Swig_var_LotType_ODD_LOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LotType_BLOCK_LOT",Swig_var_LotType_BLOCK_LOT_get, Swig_var_LotType_BLOCK_LOT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_FLAT_CURVE",Swig_var_QuoteCondition_FLAT_CURVE_get, Swig_var_QuoteCondition_FLAT_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_REST_OF_BOOK_VWAP",Swig_var_QuoteCondition_REST_OF_BOOK_VWAP_get, Swig_var_QuoteCondition_REST_OF_BOOK_VWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS",Swig_var_QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS_get, Swig_var_QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_TRADING_RANGE",Swig_var_QuoteCondition_TRADING_RANGE_get, Swig_var_QuoteCondition_TRADING_RANGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_HALT_ETH",Swig_var_QuoteCondition_HALT_ETH_get, Swig_var_QuoteCondition_HALT_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_BID_OFFER_SPECIALIST",Swig_var_QuoteCondition_BID_OFFER_SPECIALIST_get, Swig_var_QuoteCondition_BID_OFFER_SPECIALIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_CROSSED",Swig_var_QuoteCondition_CROSSED_get, Swig_var_QuoteCondition_CROSSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_NO_OPEN",Swig_var_QuoteCondition_NO_OPEN_get, Swig_var_QuoteCondition_NO_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_HALT",Swig_var_QuoteCondition_HALT_get, Swig_var_QuoteCondition_HALT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_PREOPENING_SAM",Swig_var_QuoteCondition_PREOPENING_SAM_get, Swig_var_QuoteCondition_PREOPENING_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_OPEN_SAM",Swig_var_QuoteCondition_OPEN_SAM_get, Swig_var_QuoteCondition_OPEN_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_RESERVED_SAM",Swig_var_QuoteCondition_RESERVED_SAM_get, Swig_var_QuoteCondition_RESERVED_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_OUTRIGHT_PRICE",Swig_var_QuoteCondition_OUTRIGHT_PRICE_get, Swig_var_QuoteCondition_OUTRIGHT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_IMPLIED_PRICE",Swig_var_QuoteCondition_IMPLIED_PRICE_get, Swig_var_QuoteCondition_IMPLIED_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_DEPTH_ON_OFFER",Swig_var_QuoteCondition_DEPTH_ON_OFFER_get, Swig_var_QuoteCondition_DEPTH_ON_OFFER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED",Swig_var_QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED_get, Swig_var_QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_REGULAR_ETH",Swig_var_QuoteCondition_REGULAR_ETH_get, Swig_var_QuoteCondition_REGULAR_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_ROTATION_ETH",Swig_var_QuoteCondition_ROTATION_ETH_get, Swig_var_QuoteCondition_ROTATION_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_EXCHANGE_BEST",Swig_var_QuoteCondition_EXCHANGE_BEST_get, Swig_var_QuoteCondition_EXCHANGE_BEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_DEPTH_ON_BID",Swig_var_QuoteCondition_DEPTH_ON_BID_get, Swig_var_QuoteCondition_DEPTH_ON_BID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_CLOSING",Swig_var_QuoteCondition_CLOSING_get, Swig_var_QuoteCondition_CLOSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_VIEW_OF_COMMON",Swig_var_QuoteCondition_VIEW_OF_COMMON_get, Swig_var_QuoteCondition_VIEW_OF_COMMON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_FORBIDDEN_SAM",Swig_var_QuoteCondition_FORBIDDEN_SAM_get, Swig_var_QuoteCondition_FORBIDDEN_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_LOCKED",Swig_var_QuoteCondition_LOCKED_get, Swig_var_QuoteCondition_LOCKED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_ORDER_INFLUX",Swig_var_QuoteCondition_ORDER_INFLUX_get, Swig_var_QuoteCondition_ORDER_INFLUX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_NEWS_PENDING",Swig_var_QuoteCondition_NEWS_PENDING_get, Swig_var_QuoteCondition_NEWS_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_RESUME",Swig_var_QuoteCondition_RESUME_get, Swig_var_QuoteCondition_RESUME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_TRADING_RESUME",Swig_var_QuoteCondition_TRADING_RESUME_get, Swig_var_QuoteCondition_TRADING_RESUME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_OUT_OF_SEQUENCE",Swig_var_QuoteCondition_OUT_OF_SEQUENCE_get, Swig_var_QuoteCondition_OUT_OF_SEQUENCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_END_OF_DAY_SAM",Swig_var_QuoteCondition_END_OF_DAY_SAM_get, Swig_var_QuoteCondition_END_OF_DAY_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_FROZEN_SAM",Swig_var_QuoteCondition_FROZEN_SAM_get, Swig_var_QuoteCondition_FROZEN_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_OPENING_SAM",Swig_var_QuoteCondition_OPENING_SAM_get, Swig_var_QuoteCondition_OPENING_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_MANUAL_SLOW_QUOTE",Swig_var_QuoteCondition_MANUAL_SLOW_QUOTE_get, Swig_var_QuoteCondition_MANUAL_SLOW_QUOTE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_NEWS_DISSEMINATION",Swig_var_QuoteCondition_NEWS_DISSEMINATION_get, Swig_var_QuoteCondition_NEWS_DISSEMINATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_DUE_TO_RELATED",Swig_var_QuoteCondition_DUE_TO_RELATED_get, Swig_var_QuoteCondition_DUE_TO_RELATED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_VOLUME_ALERT",Swig_var_QuoteCondition_VOLUME_ALERT_get, Swig_var_QuoteCondition_VOLUME_ALERT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_FAST_MARKET_ETH",Swig_var_QuoteCondition_FAST_MARKET_ETH_get, Swig_var_QuoteCondition_FAST_MARKET_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_INACTIVE_ETH",Swig_var_QuoteCondition_INACTIVE_ETH_get, Swig_var_QuoteCondition_INACTIVE_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_DUE_TO_NEWS_DISSEMINATION",Swig_var_QuoteCondition_DUE_TO_NEWS_DISSEMINATION_get, Swig_var_QuoteCondition_DUE_TO_NEWS_DISSEMINATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_SURVEILLANCE_SAM",Swig_var_QuoteCondition_SURVEILLANCE_SAM_get, Swig_var_QuoteCondition_SURVEILLANCE_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_DEPTH",Swig_var_QuoteCondition_DEPTH_get, Swig_var_QuoteCondition_DEPTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_OPEN",Swig_var_QuoteCondition_OPEN_get, Swig_var_QuoteCondition_OPEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_AUTOMATIC_EXECUTION",Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_get, Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_DUE_TO_NEWS_PENDING",Swig_var_QuoteCondition_DUE_TO_NEWS_PENDING_get, Swig_var_QuoteCondition_DUE_TO_NEWS_PENDING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_NO_ACTIVE_SAM",Swig_var_QuoteCondition_NO_ACTIVE_SAM_get, Swig_var_QuoteCondition_NO_ACTIVE_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_OFFER_SPECIALIST",Swig_var_QuoteCondition_OFFER_SPECIALIST_get, Swig_var_QuoteCondition_OFFER_SPECIALIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_SUSPENDED_SAM",Swig_var_QuoteCondition_SUSPENDED_SAM_get, Swig_var_QuoteCondition_SUSPENDED_SAM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_RESTRICTED",Swig_var_QuoteCondition_RESTRICTED_get, Swig_var_QuoteCondition_RESTRICTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_NON_FIRM",Swig_var_QuoteCondition_NON_FIRM_get, Swig_var_QuoteCondition_NON_FIRM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_CLOSED_INACTIVE",Swig_var_QuoteCondition_CLOSED_INACTIVE_get, Swig_var_QuoteCondition_CLOSED_INACTIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_ADDITIONAL_INFO",Swig_var_QuoteCondition_ADDITIONAL_INFO_get, Swig_var_QuoteCondition_ADDITIONAL_INFO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_EQUIPMENT_CHANGEOVER",Swig_var_QuoteCondition_EQUIPMENT_CHANGEOVER_get, Swig_var_QuoteCondition_EQUIPMENT_CHANGEOVER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_FAST_TRADING",Swig_var_QuoteCondition_FAST_TRADING_get, Swig_var_QuoteCondition_FAST_TRADING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_FULL_CURVE",Swig_var_QuoteCondition_FULL_CURVE_get, Swig_var_QuoteCondition_FULL_CURVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_MEDIAN_PRICE",Swig_var_QuoteCondition_MEDIAN_PRICE_get, Swig_var_QuoteCondition_MEDIAN_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_OPEN_ACTIVE",Swig_var_QuoteCondition_OPEN_ACTIVE_get, Swig_var_QuoteCondition_OPEN_ACTIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_ORDER_IMBALANCE",Swig_var_QuoteCondition_ORDER_IMBALANCE_get, Swig_var_QuoteCondition_ORDER_IMBALANCE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_AUTOMATIC_EXECUTION_ETH",Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_ETH_get, Swig_var_QuoteCondition_AUTOMATIC_EXECUTION_ETH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_ROTATION",Swig_var_QuoteCondition_ROTATION_get, Swig_var_QuoteCondition_ROTATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_BID_SPECIALIST",Swig_var_QuoteCondition_BID_SPECIALIST_get, Swig_var_QuoteCondition_BID_SPECIALIST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_CONSOLIDATED_BEST",Swig_var_QuoteCondition_CONSOLIDATED_BEST_get, Swig_var_QuoteCondition_CONSOLIDATED_BEST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteCondition_CLOSED",Swig_var_QuoteCondition_CLOSED_get, Swig_var_QuoteCondition_CLOSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_EUROCLEAR",Swig_var_SettlLocation_EUROCLEAR_get, Swig_var_SettlLocation_EUROCLEAR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_CEDEL",Swig_var_SettlLocation_CEDEL_get, Swig_var_SettlLocation_CEDEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_PARTICIPANT_TRUST_COMPANY",Swig_var_SettlLocation_PARTICIPANT_TRUST_COMPANY_get, Swig_var_SettlLocation_PARTICIPANT_TRUST_COMPANY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_PHYSICAL",Swig_var_SettlLocation_PHYSICAL_get, Swig_var_SettlLocation_PHYSICAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_DEPOSITORY_TRUST_COMPANY",Swig_var_SettlLocation_DEPOSITORY_TRUST_COMPANY_get, Swig_var_SettlLocation_DEPOSITORY_TRUST_COMPANY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_LOCAL_MARKET_SETTLE_LOCATION",Swig_var_SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_get, Swig_var_SettlLocation_LOCAL_MARKET_SETTLE_LOCATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SettlLocation_FEDERAL_BOOK_ENTRY",Swig_var_SettlLocation_FEDERAL_BOOK_ENTRY_get, Swig_var_SettlLocation_FEDERAL_BOOK_ENTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionScope_NATIONAL_EXCLUDING_LOCAL",Swig_var_DiscretionScope_NATIONAL_EXCLUDING_LOCAL_get, Swig_var_DiscretionScope_NATIONAL_EXCLUDING_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionScope_LOCAL",Swig_var_DiscretionScope_LOCAL_get, Swig_var_DiscretionScope_LOCAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionScope_GLOBAL",Swig_var_DiscretionScope_GLOBAL_get, Swig_var_DiscretionScope_GLOBAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionScope_NATIONAL",Swig_var_DiscretionScope_NATIONAL_get, Swig_var_DiscretionScope_NATIONAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_PUBLIC_COMPANY",Swig_var_OwnerType_PUBLIC_COMPANY_get, Swig_var_OwnerType_PUBLIC_COMPANY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_INDIVIDUAL_TRUSTEE",Swig_var_OwnerType_INDIVIDUAL_TRUSTEE_get, Swig_var_OwnerType_INDIVIDUAL_TRUSTEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT",Swig_var_OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT_get, Swig_var_OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_INDIVIDUAL_INVESTOR",Swig_var_OwnerType_INDIVIDUAL_INVESTOR_get, Swig_var_OwnerType_INDIVIDUAL_INVESTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_COMPANY_TRUSTEE",Swig_var_OwnerType_COMPANY_TRUSTEE_get, Swig_var_OwnerType_COMPANY_TRUSTEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_PRIVATE_COMPANY",Swig_var_OwnerType_PRIVATE_COMPANY_get, Swig_var_OwnerType_PRIVATE_COMPANY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_NETWORKING_SUB_ACCOUNT",Swig_var_OwnerType_NETWORKING_SUB_ACCOUNT_get, Swig_var_OwnerType_NETWORKING_SUB_ACCOUNT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_PENSION_PLAN",Swig_var_OwnerType_PENSION_PLAN_get, Swig_var_OwnerType_PENSION_PLAN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_TRUSTS",Swig_var_OwnerType_TRUSTS_get, Swig_var_OwnerType_TRUSTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_FIDUCIARIES",Swig_var_OwnerType_FIDUCIARIES_get, Swig_var_OwnerType_FIDUCIARIES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_NON_PROFIT_ORGANIZATION",Swig_var_OwnerType_NON_PROFIT_ORGANIZATION_get, Swig_var_OwnerType_NON_PROFIT_ORGANIZATION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_CORPORATE_BODY",Swig_var_OwnerType_CORPORATE_BODY_get, Swig_var_OwnerType_CORPORATE_BODY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"OwnerType_NOMINEE",Swig_var_OwnerType_NOMINEE_get, Swig_var_OwnerType_NOMINEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueResolution_END_SESSION",Swig_var_ApplQueueResolution_END_SESSION_get, Swig_var_ApplQueueResolution_END_SESSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueResolution_QUEUE_FLUSHED",Swig_var_ApplQueueResolution_QUEUE_FLUSHED_get, Swig_var_ApplQueueResolution_QUEUE_FLUSHED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueResolution_OVERLAY_LAST",Swig_var_ApplQueueResolution_OVERLAY_LAST_get, Swig_var_ApplQueueResolution_OVERLAY_LAST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplQueueResolution_NO_ACTION_TAKEN",Swig_var_ApplQueueResolution_NO_ACTION_TAKEN_get, Swig_var_ApplQueueResolution_NO_ACTION_TAKEN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT",Swig_var_QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_get, Swig_var_QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES",Swig_var_QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES_get, Swig_var_QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE",Swig_var_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE_get, Swig_var_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES",Swig_var_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES_get, Swig_var_QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteResponseLevel_NO_ACKNOWLEDGEMENT",Swig_var_QuoteResponseLevel_NO_ACKNOWLEDGEMENT_get, Swig_var_QuoteResponseLevel_NO_ACKNOWLEDGEMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecAckStatus_RECEIVED_NOT_YET_PROCESSED",Swig_var_ExecAckStatus_RECEIVED_NOT_YET_PROCESSED_get, Swig_var_ExecAckStatus_RECEIVED_NOT_YET_PROCESSED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecAckStatus_DONT_KNOW",Swig_var_ExecAckStatus_DONT_KNOW_get, Swig_var_ExecAckStatus_DONT_KNOW_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ExecAckStatus_ACCEPTED",Swig_var_ExecAckStatus_ACCEPTED_get, Swig_var_ExecAckStatus_ACCEPTED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetGrossInd_NET",Swig_var_NetGrossInd_NET_get, Swig_var_NetGrossInd_NET_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetGrossInd_GROSS",Swig_var_NetGrossInd_GROSS_get, Swig_var_NetGrossInd_GROSS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlType_PARTIAL_CANCEL",Swig_var_CxlType_PARTIAL_CANCEL_get, Swig_var_CxlType_PARTIAL_CANCEL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CxlType_FULL_REMAINING_QUANTITY",Swig_var_CxlType_FULL_REMAINING_QUANTITY_get, Swig_var_CxlType_FULL_REMAINING_QUANTITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DeskTypeSource_NASD_OATS",Swig_var_DeskTypeSource_NASD_OATS_get, Swig_var_DeskTypeSource_NASD_OATS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK",Swig_var_DiscretionRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK_get, Swig_var_DiscretionRoundDirection_MORE_AGGRESSIVE_ON_A_BUY_ORDER_ROUND_THE_PRICE_UP_ROUND_UP_TO_THE_NEAREST_TICK_ON_A_SELL_ROUND_DOWN_TO_THE_NEAREST_TICK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionRoundDirection_MORE_AGGRESSIVE",Swig_var_DiscretionRoundDirection_MORE_AGGRESSIVE_get, Swig_var_DiscretionRoundDirection_MORE_AGGRESSIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionRoundDirection_MORE_PASSIVE",Swig_var_DiscretionRoundDirection_MORE_PASSIVE_get, Swig_var_DiscretionRoundDirection_MORE_PASSIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK",Swig_var_DiscretionRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK_get, Swig_var_DiscretionRoundDirection_MORE_PASSIVE_ON_A_BUY_ORDER_ROUND_DOWN_TO_NEAREST_TICK_ON_A_SELL_ORDER_ROUND_UP_TO_NEAREST_TICK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidDescriptorType_COUNTRY",Swig_var_BidDescriptorType_COUNTRY_get, Swig_var_BidDescriptorType_COUNTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidDescriptorType_INDEX",Swig_var_BidDescriptorType_INDEX_get, Swig_var_BidDescriptorType_INDEX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BidDescriptorType_SECTOR",Swig_var_BidDescriptorType_SECTOR_get, Swig_var_BidDescriptorType_SECTOR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkStatusResponseType_INCREMENTAL_UPDATE",Swig_var_NetworkStatusResponseType_INCREMENTAL_UPDATE_get, Swig_var_NetworkStatusResponseType_INCREMENTAL_UPDATE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"NetworkStatusResponseType_FULL",Swig_var_NetworkStatusResponseType_FULL_get, Swig_var_NetworkStatusResponseType_FULL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteType_INDICATIVE",Swig_var_QuoteType_INDICATIVE_get, Swig_var_QuoteType_INDICATIVE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteType_RESTRICTED_TRADEABLE",Swig_var_QuoteType_RESTRICTED_TRADEABLE_get, Swig_var_QuoteType_RESTRICTED_TRADEABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteType_TRADEABLE",Swig_var_QuoteType_TRADEABLE_get, Swig_var_QuoteType_TRADEABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"QuoteType_COUNTER",Swig_var_QuoteType_COUNTER_get, Swig_var_QuoteType_COUNTER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELATED_TO_MARKET_PRICE",Swig_var_DiscretionInst_RELATED_TO_MARKET_PRICE_get, Swig_var_DiscretionInst_RELATED_TO_MARKET_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELATED_TO_VWAP",Swig_var_DiscretionInst_RELATED_TO_VWAP_get, Swig_var_DiscretionInst_RELATED_TO_VWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELATED_TO_MIDPOINT_PRICE",Swig_var_DiscretionInst_RELATED_TO_MIDPOINT_PRICE_get, Swig_var_DiscretionInst_RELATED_TO_MIDPOINT_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELATED_TO_DISPLAYED_PRICE",Swig_var_DiscretionInst_RELATED_TO_DISPLAYED_PRICE_get, Swig_var_DiscretionInst_RELATED_TO_DISPLAYED_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELATED_TO_PRIMARY_PRICE",Swig_var_DiscretionInst_RELATED_TO_PRIMARY_PRICE_get, Swig_var_DiscretionInst_RELATED_TO_PRIMARY_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_AVERAGE_PRICE_GUARANTEE",Swig_var_DiscretionInst_AVERAGE_PRICE_GUARANTEE_get, Swig_var_DiscretionInst_AVERAGE_PRICE_GUARANTEE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELATED_TO_LAST_TRADE_PRICE",Swig_var_DiscretionInst_RELATED_TO_LAST_TRADE_PRICE_get, Swig_var_DiscretionInst_RELATED_TO_LAST_TRADE_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE",Swig_var_DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE_get, Swig_var_DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossPrioritization_BUY_SIDE_IS_PRIORITIZED",Swig_var_CrossPrioritization_BUY_SIDE_IS_PRIORITIZED_get, Swig_var_CrossPrioritization_BUY_SIDE_IS_PRIORITIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossPrioritization_SELL_SIDE_IS_PRIORITIZED",Swig_var_CrossPrioritization_SELL_SIDE_IS_PRIORITIZED_get, Swig_var_CrossPrioritization_SELL_SIDE_IS_PRIORITIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossPrioritization_NONE",Swig_var_CrossPrioritization_NONE_get, Swig_var_CrossPrioritization_NONE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossPrioritization_SELLSIDE_PRIORITIZED",Swig_var_CrossPrioritization_SELLSIDE_PRIORITIZED_get, Swig_var_CrossPrioritization_SELLSIDE_PRIORITIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CrossPrioritization_BUYSIDE_PRIORITIZED",Swig_var_CrossPrioritization_BUYSIDE_PRIORITIZED_get, Swig_var_CrossPrioritization_BUYSIDE_PRIORITIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIOthSvc_AUTEX",Swig_var_IOIOthSvc_AUTEX_get, Swig_var_IOIOthSvc_AUTEX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"IOIOthSvc_BRIDGE",Swig_var_IOIOthSvc_BRIDGE_get, Swig_var_IOIOthSvc_BRIDGE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_MDENTRYTYPE",Swig_var_MDReqRejReason_UNSUPPORTED_MDENTRYTYPE_get, Swig_var_MDReqRejReason_UNSUPPORTED_MDENTRYTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_INSUFFICIENT_CREDIT",Swig_var_MDReqRejReason_INSUFFICIENT_CREDIT_get, Swig_var_MDReqRejReason_INSUFFICIENT_CREDIT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_INSUFFICIENT_BANDWIDTH",Swig_var_MDReqRejReason_INSUFFICIENT_BANDWIDTH_get, Swig_var_MDReqRejReason_INSUFFICIENT_BANDWIDTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_SCOPE",Swig_var_MDReqRejReason_UNSUPPORTED_SCOPE_get, Swig_var_MDReqRejReason_UNSUPPORTED_SCOPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID",Swig_var_MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID_get, Swig_var_MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_DUPLICATE_MDREQID",Swig_var_MDReqRejReason_DUPLICATE_MDREQID_get, Swig_var_MDReqRejReason_DUPLICATE_MDREQID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK",Swig_var_MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK_get, Swig_var_MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_MDUPDATETYPE",Swig_var_MDReqRejReason_UNSUPPORTED_MDUPDATETYPE_get, Swig_var_MDReqRejReason_UNSUPPORTED_MDUPDATETYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE",Swig_var_MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE_get, Swig_var_MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNKNOWN_SYMBOL",Swig_var_MDReqRejReason_UNKNOWN_SYMBOL_get, Swig_var_MDReqRejReason_UNKNOWN_SYMBOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG",Swig_var_MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG_get, Swig_var_MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_MARKETDEPTH",Swig_var_MDReqRejReason_UNSUPPORTED_MARKETDEPTH_get, Swig_var_MDReqRejReason_UNSUPPORTED_MARKETDEPTH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_INSUFFICIENT_PERMISSIONS",Swig_var_MDReqRejReason_INSUFFICIENT_PERMISSIONS_get, Swig_var_MDReqRejReason_INSUFFICIENT_PERMISSIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE",Swig_var_MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE_get, Swig_var_MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS",Swig_var_ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS_get, Swig_var_ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS",Swig_var_ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_get, Swig_var_ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS",Swig_var_ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_get, Swig_var_ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS",Swig_var_ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS_get, Swig_var_ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS",Swig_var_ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS_get, Swig_var_ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS",Swig_var_ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS_get, Swig_var_ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ApplReqType_CANCEL_RETRANSMISSION",Swig_var_ApplReqType_CANCEL_RETRANSMISSION_get, Swig_var_ApplReqType_CANCEL_RETRANSMISSION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AggressorIndicator_NO",Swig_var_AggressorIndicator_NO_get, Swig_var_AggressorIndicator_NO_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"AggressorIndicator_YES",Swig_var_AggressorIndicator_YES_get, Swig_var_AggressorIndicator_YES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKNOWN_SECURITY",Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_get, Swig_var_BusinessRejectReason_UNKNOWN_SECURITY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_APPLICATION_NOT_AVAILABLE",Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_get, Swig_var_BusinessRejectReason_APPLICATION_NOT_AVAILABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_INVALID_PRICE_INCREMENT",Swig_var_BusinessRejectReason_INVALID_PRICE_INCREMENT_get, Swig_var_BusinessRejectReason_INVALID_PRICE_INCREMENT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME",Swig_var_BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_get, Swig_var_BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING",Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_get, Swig_var_BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKNOWN_ID",Swig_var_BusinessRejectReason_UNKNOWN_ID_get, Swig_var_BusinessRejectReason_UNKNOWN_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_OTHER",Swig_var_BusinessRejectReason_OTHER_get, Swig_var_BusinessRejectReason_OTHER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE",Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_get, Swig_var_BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKNOWN_MESSAGE_TYPE",Swig_var_BusinessRejectReason_UNKNOWN_MESSAGE_TYPE_get, Swig_var_BusinessRejectReason_UNKNOWN_MESSAGE_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_NOT_AUTHORIZED",Swig_var_BusinessRejectReason_NOT_AUTHORIZED_get, Swig_var_BusinessRejectReason_NOT_AUTHORIZED_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BusinessRejectReason_UNKOWN_ID",Swig_var_BusinessRejectReason_UNKOWN_ID_get, Swig_var_BusinessRejectReason_UNKOWN_ID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BookingType_REGULAR_BOOKING",Swig_var_BookingType_REGULAR_BOOKING_get, Swig_var_BookingType_REGULAR_BOOKING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BookingType_CFD",Swig_var_BookingType_CFD_get, Swig_var_BookingType_CFD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BookingType_TOTAL_RETURN_SWAP",Swig_var_BookingType_TOTAL_RETURN_SWAP_get, Swig_var_BookingType_TOTAL_RETURN_SWAP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"BEGINSTRING",Swig_var_BEGINSTRING_get, Swig_var_BEGINSTRING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SENDERCOMPID",Swig_var_SENDERCOMPID_get, Swig_var_SENDERCOMPID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TARGETCOMPID",Swig_var_TARGETCOMPID_get, Swig_var_TARGETCOMPID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SESSION_QUALIFIER",Swig_var_SESSION_QUALIFIER_get, Swig_var_SESSION_QUALIFIER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DEFAULT_APPLVERID",Swig_var_DEFAULT_APPLVERID_get, Swig_var_DEFAULT_APPLVERID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CONNECTION_TYPE",Swig_var_CONNECTION_TYPE_get, Swig_var_CONNECTION_TYPE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"USE_DATA_DICTIONARY",Swig_var_USE_DATA_DICTIONARY_get, Swig_var_USE_DATA_DICTIONARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SEND_RESETSEQNUMFLAG",Swig_var_SEND_RESETSEQNUMFLAG_get, Swig_var_SEND_RESETSEQNUMFLAG_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SEND_REDUNDANT_RESENDREQUESTS",Swig_var_SEND_REDUNDANT_RESENDREQUESTS_get, Swig_var_SEND_REDUNDANT_RESENDREQUESTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"DATA_DICTIONARY",Swig_var_DATA_DICTIONARY_get, Swig_var_DATA_DICTIONARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"TRANSPORT_DATA_DICTIONARY",Swig_var_TRANSPORT_DATA_DICTIONARY_get, Swig_var_TRANSPORT_DATA_DICTIONARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"APP_DATA_DICTIONARY",Swig_var_APP_DATA_DICTIONARY_get, Swig_var_APP_DATA_DICTIONARY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"USE_LOCAL_TIME",Swig_var_USE_LOCAL_TIME_get, Swig_var_USE_LOCAL_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"START_TIME",Swig_var_START_TIME_get, Swig_var_START_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"END_TIME",Swig_var_END_TIME_get, Swig_var_END_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"START_DAY",Swig_var_START_DAY_get, Swig_var_START_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"END_DAY",Swig_var_END_DAY_get, Swig_var_END_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LOGON_TIME",Swig_var_LOGON_TIME_get, Swig_var_LOGON_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LOGOUT_TIME",Swig_var_LOGOUT_TIME_get, Swig_var_LOGOUT_TIME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LOGON_DAY",Swig_var_LOGON_DAY_get, Swig_var_LOGON_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LOGOUT_DAY",Swig_var_LOGOUT_DAY_get, Swig_var_LOGOUT_DAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CHECK_COMPID",Swig_var_CHECK_COMPID_get, Swig_var_CHECK_COMPID_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"CHECK_LATENCY",Swig_var_CHECK_LATENCY_get, Swig_var_CHECK_LATENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MAX_LATENCY",Swig_var_MAX_LATENCY_get, Swig_var_MAX_LATENCY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HEARTBTINT",Swig_var_HEARTBTINT_get, Swig_var_HEARTBTINT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SOCKET_ACCEPT_PORT",Swig_var_SOCKET_ACCEPT_PORT_get, Swig_var_SOCKET_ACCEPT_PORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SOCKET_REUSE_ADDRESS",Swig_var_SOCKET_REUSE_ADDRESS_get, Swig_var_SOCKET_REUSE_ADDRESS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SOCKET_CONNECT_HOST",Swig_var_SOCKET_CONNECT_HOST_get, Swig_var_SOCKET_CONNECT_HOST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SOCKET_CONNECT_PORT",Swig_var_SOCKET_CONNECT_PORT_get, Swig_var_SOCKET_CONNECT_PORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SOCKET_NODELAY",Swig_var_SOCKET_NODELAY_get, Swig_var_SOCKET_NODELAY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SOCKET_SEND_BUFFER_SIZE",Swig_var_SOCKET_SEND_BUFFER_SIZE_get, Swig_var_SOCKET_SEND_BUFFER_SIZE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SOCKET_RECEIVE_BUFFER_SIZE",Swig_var_SOCKET_RECEIVE_BUFFER_SIZE_get, Swig_var_SOCKET_RECEIVE_BUFFER_SIZE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RECONNECT_INTERVAL",Swig_var_RECONNECT_INTERVAL_get, Swig_var_RECONNECT_INTERVAL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"VALIDATE_LENGTH_AND_CHECKSUM",Swig_var_VALIDATE_LENGTH_AND_CHECKSUM_get, Swig_var_VALIDATE_LENGTH_AND_CHECKSUM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"VALIDATE_FIELDS_OUT_OF_ORDER",Swig_var_VALIDATE_FIELDS_OUT_OF_ORDER_get, Swig_var_VALIDATE_FIELDS_OUT_OF_ORDER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"VALIDATE_FIELDS_HAVE_VALUES",Swig_var_VALIDATE_FIELDS_HAVE_VALUES_get, Swig_var_VALIDATE_FIELDS_HAVE_VALUES_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"VALIDATE_USER_DEFINED_FIELDS",Swig_var_VALIDATE_USER_DEFINED_FIELDS_get, Swig_var_VALIDATE_USER_DEFINED_FIELDS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LOGON_TIMEOUT",Swig_var_LOGON_TIMEOUT_get, Swig_var_LOGON_TIMEOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LOGOUT_TIMEOUT",Swig_var_LOGOUT_TIMEOUT_get, Swig_var_LOGOUT_TIMEOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FILE_STORE_PATH",Swig_var_FILE_STORE_PATH_get, Swig_var_FILE_STORE_PATH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_STORE_USECONNECTIONPOOL",Swig_var_MYSQL_STORE_USECONNECTIONPOOL_get, Swig_var_MYSQL_STORE_USECONNECTIONPOOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_STORE_DATABASE",Swig_var_MYSQL_STORE_DATABASE_get, Swig_var_MYSQL_STORE_DATABASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_STORE_USER",Swig_var_MYSQL_STORE_USER_get, Swig_var_MYSQL_STORE_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_STORE_PASSWORD",Swig_var_MYSQL_STORE_PASSWORD_get, Swig_var_MYSQL_STORE_PASSWORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_STORE_HOST",Swig_var_MYSQL_STORE_HOST_get, Swig_var_MYSQL_STORE_HOST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_STORE_PORT",Swig_var_MYSQL_STORE_PORT_get, Swig_var_MYSQL_STORE_PORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_STORE_USECONNECTIONPOOL",Swig_var_POSTGRESQL_STORE_USECONNECTIONPOOL_get, Swig_var_POSTGRESQL_STORE_USECONNECTIONPOOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_STORE_DATABASE",Swig_var_POSTGRESQL_STORE_DATABASE_get, Swig_var_POSTGRESQL_STORE_DATABASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_STORE_USER",Swig_var_POSTGRESQL_STORE_USER_get, Swig_var_POSTGRESQL_STORE_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_STORE_PASSWORD",Swig_var_POSTGRESQL_STORE_PASSWORD_get, Swig_var_POSTGRESQL_STORE_PASSWORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_STORE_HOST",Swig_var_POSTGRESQL_STORE_HOST_get, Swig_var_POSTGRESQL_STORE_HOST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_STORE_PORT",Swig_var_POSTGRESQL_STORE_PORT_get, Swig_var_POSTGRESQL_STORE_PORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_STORE_USER",Swig_var_ODBC_STORE_USER_get, Swig_var_ODBC_STORE_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_STORE_PASSWORD",Swig_var_ODBC_STORE_PASSWORD_get, Swig_var_ODBC_STORE_PASSWORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_STORE_CONNECTION_STRING",Swig_var_ODBC_STORE_CONNECTION_STRING_get, Swig_var_ODBC_STORE_CONNECTION_STRING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FILE_LOG_PATH",Swig_var_FILE_LOG_PATH_get, Swig_var_FILE_LOG_PATH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"FILE_LOG_BACKUP_PATH",Swig_var_FILE_LOG_BACKUP_PATH_get, Swig_var_FILE_LOG_BACKUP_PATH_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SCREEN_LOG_SHOW_INCOMING",Swig_var_SCREEN_LOG_SHOW_INCOMING_get, Swig_var_SCREEN_LOG_SHOW_INCOMING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SCREEN_LOG_SHOW_OUTGOING",Swig_var_SCREEN_LOG_SHOW_OUTGOING_get, Swig_var_SCREEN_LOG_SHOW_OUTGOING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SCREEN_LOG_SHOW_EVENTS",Swig_var_SCREEN_LOG_SHOW_EVENTS_get, Swig_var_SCREEN_LOG_SHOW_EVENTS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_USECONNECTIONPOOL",Swig_var_MYSQL_LOG_USECONNECTIONPOOL_get, Swig_var_MYSQL_LOG_USECONNECTIONPOOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_DATABASE",Swig_var_MYSQL_LOG_DATABASE_get, Swig_var_MYSQL_LOG_DATABASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_USER",Swig_var_MYSQL_LOG_USER_get, Swig_var_MYSQL_LOG_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_PASSWORD",Swig_var_MYSQL_LOG_PASSWORD_get, Swig_var_MYSQL_LOG_PASSWORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_HOST",Swig_var_MYSQL_LOG_HOST_get, Swig_var_MYSQL_LOG_HOST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_PORT",Swig_var_MYSQL_LOG_PORT_get, Swig_var_MYSQL_LOG_PORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_INCOMING_TABLE",Swig_var_MYSQL_LOG_INCOMING_TABLE_get, Swig_var_MYSQL_LOG_INCOMING_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_OUTGOING_TABLE",Swig_var_MYSQL_LOG_OUTGOING_TABLE_get, Swig_var_MYSQL_LOG_OUTGOING_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MYSQL_LOG_EVENT_TABLE",Swig_var_MYSQL_LOG_EVENT_TABLE_get, Swig_var_MYSQL_LOG_EVENT_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_USECONNECTIONPOOL",Swig_var_POSTGRESQL_LOG_USECONNECTIONPOOL_get, Swig_var_POSTGRESQL_LOG_USECONNECTIONPOOL_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_DATABASE",Swig_var_POSTGRESQL_LOG_DATABASE_get, Swig_var_POSTGRESQL_LOG_DATABASE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_USER",Swig_var_POSTGRESQL_LOG_USER_get, Swig_var_POSTGRESQL_LOG_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_PASSWORD",Swig_var_POSTGRESQL_LOG_PASSWORD_get, Swig_var_POSTGRESQL_LOG_PASSWORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_HOST",Swig_var_POSTGRESQL_LOG_HOST_get, Swig_var_POSTGRESQL_LOG_HOST_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_PORT",Swig_var_POSTGRESQL_LOG_PORT_get, Swig_var_POSTGRESQL_LOG_PORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_INCOMING_TABLE",Swig_var_POSTGRESQL_LOG_INCOMING_TABLE_get, Swig_var_POSTGRESQL_LOG_INCOMING_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_OUTGOING_TABLE",Swig_var_POSTGRESQL_LOG_OUTGOING_TABLE_get, Swig_var_POSTGRESQL_LOG_OUTGOING_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"POSTGRESQL_LOG_EVENT_TABLE",Swig_var_POSTGRESQL_LOG_EVENT_TABLE_get, Swig_var_POSTGRESQL_LOG_EVENT_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_LOG_USER",Swig_var_ODBC_LOG_USER_get, Swig_var_ODBC_LOG_USER_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_LOG_PASSWORD",Swig_var_ODBC_LOG_PASSWORD_get, Swig_var_ODBC_LOG_PASSWORD_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_LOG_CONNECTION_STRING",Swig_var_ODBC_LOG_CONNECTION_STRING_get, Swig_var_ODBC_LOG_CONNECTION_STRING_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_LOG_INCOMING_TABLE",Swig_var_ODBC_LOG_INCOMING_TABLE_get, Swig_var_ODBC_LOG_INCOMING_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_LOG_OUTGOING_TABLE",Swig_var_ODBC_LOG_OUTGOING_TABLE_get, Swig_var_ODBC_LOG_OUTGOING_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ODBC_LOG_EVENT_TABLE",Swig_var_ODBC_LOG_EVENT_TABLE_get, Swig_var_ODBC_LOG_EVENT_TABLE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RESET_ON_LOGON",Swig_var_RESET_ON_LOGON_get, Swig_var_RESET_ON_LOGON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RESET_ON_LOGOUT",Swig_var_RESET_ON_LOGOUT_get, Swig_var_RESET_ON_LOGOUT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"RESET_ON_DISCONNECT",Swig_var_RESET_ON_DISCONNECT_get, Swig_var_RESET_ON_DISCONNECT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"REFRESH_ON_LOGON",Swig_var_REFRESH_ON_LOGON_get, Swig_var_REFRESH_ON_LOGON_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"MILLISECONDS_IN_TIMESTAMP",Swig_var_MILLISECONDS_IN_TIMESTAMP_get, Swig_var_MILLISECONDS_IN_TIMESTAMP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"HTTP_ACCEPT_PORT",Swig_var_HTTP_ACCEPT_PORT_get, Swig_var_HTTP_ACCEPT_PORT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PERSIST_MESSAGES",Swig_var_PERSIST_MESSAGES_get, Swig_var_PERSIST_MESSAGES_set);
  
#ifndef _MSC_VER
  struct sigaction new_action, old_action;
  new_action.sa_handler = SIG_DFL;
  sigemptyset( &new_action.sa_mask );
  new_action.sa_flags = 0;
  sigaction( SIGINT, &new_action, &old_action );
#endif
  
  
  /* Initialize threading */
  SWIG_PYTHON_INITIALIZE_THREADS;
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}